@wular/coder 0.4.3 → 0.4.5

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-9hz3s0m8.js

@@ -0,0 +1,851 @@
+// @bun
+import {
+  scanRootParamTypes
+} from "./index-v1ags1na.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  ensureDir,
+  toPosixPath
+} from "./index-4da76t62.js";
+
+// src/compat/typed-routes/generate.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import path2 from "path";
+
+// src/compat/typed-routes/manifest.ts
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+import path from "path";
+var PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js", "mdx", "md"];
+var LAYOUT_NAMES = new Set(PAGE_EXTENSIONS.map((ext) => `layout.${ext}`));
+function isGroupSegment(name) {
+  return name.startsWith("(") && name.endsWith(")");
+}
+function isSlotSegment(name) {
+  return name.startsWith("@");
+}
+function decodeLiteral(segment) {
+  return segment.replace(/%5[Ff]/g, "_");
+}
+function groupsFromBracketRoute(route) {
+  const groups = {};
+  let pos = 1;
+  for (const segment of route.split("/").filter(Boolean)) {
+    const optionalCatchAll = /^\[\[\.\.\.(.+)\]\]$/.exec(segment);
+    if (optionalCatchAll?.[1]) {
+      groups[optionalCatchAll[1]] = { pos: pos++, repeat: true, optional: true };
+      continue;
+    }
+    const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
+    if (catchAll?.[1]) {
+      groups[catchAll[1]] = { pos: pos++, repeat: true, optional: false };
+      continue;
+    }
+    const param = /^\[(.+)\]$/.exec(segment);
+    if (param?.[1]) {
+      groups[param[1]] = { pos: pos++, repeat: false, optional: false };
+    }
+  }
+  return groups;
+}
+function bracketRouteFromEntry(entry) {
+  const segments = entry.route.split("/").filter(Boolean).map((segment) => {
+    const catchAll = /^:(.+)\*$/.exec(segment);
+    if (catchAll?.[1]) {
+      const name = catchAll[1];
+      return name === entry.catchAll && entry.catchAllOptional ? `[[...${name}]]` : `[...${name}]`;
+    }
+    const param = /^:(.+)$/.exec(segment);
+    if (param?.[1])
+      return `[${param[1]}]`;
+    return segment;
+  });
+  return `/${segments.join("/")}`.replace(/\/$/, "") || "/";
+}
+function bracketRouteFromDir(relativeDir) {
+  const segments = [];
+  for (const segment of relativeDir.split("/").filter(Boolean)) {
+    if (isGroupSegment(segment) || isSlotSegment(segment))
+      continue;
+    if (/^\[\[?\.\.\..+\]\]?$/.test(segment) || /^\[.+\]$/.test(segment)) {
+      segments.push(segment);
+    } else {
+      segments.push(decodeLiteral(segment));
+    }
+  }
+  return `/${segments.join("/")}`.replace(/\/$/, "") || "/";
+}
+function pagesRouteFromRelative(relative) {
+  const withoutExt = relative.replace(/\.[^.]+$/, "");
+  const trimmed = withoutExt.replace(/\/index$/, "").replace(/^index$/, "");
+  const route = `/${trimmed}`.replace(/\/$/, "") || "/";
+  return route;
+}
+async function walkFiles(dir) {
+  if (!existsSync(dir))
+    return [];
+  const out = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      out.push(...await walkFiles(full));
+    else
+      out.push(full);
+  }
+  return out;
+}
+function isPrivate(relativeDir) {
+  return relativeDir.split("/").some((seg) => seg.startsWith("_") && !isGroupSegment(seg) && !isSlotSegment(seg));
+}
+function convertCustomRouteSource(source) {
+  const normalized = source.startsWith("/") ? source : `/${source}`;
+  const converted = normalized.split("/").map((segment) => {
+    const optional = /^:(.+)\*$/.exec(segment);
+    if (optional?.[1])
+      return `[[...${optional[1]}]]`;
+    const catchAll = /^:(.+)\+$/.exec(segment);
+    if (catchAll?.[1])
+      return `[...${catchAll[1]}]`;
+    const param = /^:([A-Za-z0-9_]+)$/.exec(segment);
+    if (param?.[1])
+      return `[${param[1]}]`;
+    return segment;
+  }).join("/");
+  return [converted.replace(/\/$/, "") || "/"];
+}
+async function buildRouteTypesManifest({
+  config,
+  routes,
+  nextConfig
+}) {
+  const relApp = (file) => toPosixPath(path.relative(config.root, file));
+  const isHybrid = config.appPath.includes("pnext-pages-compat");
+  const sourceAppPath = (entry) => {
+    if (!isHybrid)
+      return entry.file;
+    const basename = entry.kind === "page" ? /^page\.(?:tsx?|jsx?|mdx?)$/ : /^route\.(?:tsx?|jsx?)$/;
+    const source = entry.sourceFiles.find((file) => {
+      const normalized = toPosixPath(file);
+      return normalized.includes("/source-app/") && basename.test(path.basename(normalized));
+    });
+    if (!source)
+      return;
+    const relative = toPosixPath(source).split("/source-app/")[1];
+    return relative ? path.join(config.root, "app", relative) : undefined;
+  };
+  const manifest = {
+    appRoutes: {},
+    pageRoutes: {},
+    layoutRoutes: {},
+    appRouteHandlerRoutes: {},
+    redirectRoutes: {},
+    rewriteRoutes: {},
+    appPagePaths: new Set,
+    pagesRouterPagePaths: new Set,
+    layoutPaths: new Set,
+    appRouteHandlers: new Set,
+    pageApiRoutes: new Set,
+    filePathToRoute: new Map
+  };
+  const hybridFilteredRoutes = isHybrid ? routes.filter((entry) => {
+    const file = entry.file;
+    if (!file.includes("pnext-pages-compat"))
+      return true;
+    const sourceFiles = entry.sourceFiles ?? [];
+    const isPagesWrapper = sourceFiles.some((sf) => sf.includes("source-pages"));
+    if (isPagesWrapper)
+      return false;
+    return true;
+  }) : routes;
+  for (const entry of hybridFilteredRoutes) {
+    if (entry.synthetic || entry.interception || entry.metadataRoute)
+      continue;
+    const source = sourceAppPath(entry);
+    if (!source)
+      continue;
+    const bracket = bracketRouteFromEntry(entry);
+    const rel = relApp(source);
+    const info = { path: rel, groups: groupsFromBracketRoute(bracket) };
+    if (entry.kind === "page") {
+      if (!manifest.appRoutes[bracket])
+        manifest.appRoutes[bracket] = info;
+    } else {
+      if (!manifest.appRouteHandlerRoutes[bracket])
+        manifest.appRouteHandlerRoutes[bracket] = info;
+      manifest.appRouteHandlers.add(rel);
+      manifest.filePathToRoute.set(rel, bracket);
+    }
+  }
+  const appFiles = await walkFiles(isHybrid ? path.join(config.root, "app") : config.appPath);
+  const appPath = isHybrid ? path.join(config.root, "app") : config.appPath;
+  for (const file of appFiles) {
+    const relative = toPosixPath(path.relative(appPath, file));
+    const base = path.basename(relative);
+    if (!LAYOUT_NAMES.has(base))
+      continue;
+    const dir = path.dirname(relative) === "." ? "" : path.dirname(relative);
+    if (isPrivate(dir))
+      continue;
+    const bracket = bracketRouteFromDir(dir);
+    const rel = relApp(file);
+    if (!manifest.layoutRoutes[bracket]) {
+      manifest.layoutRoutes[bracket] = {
+        path: rel,
+        groups: groupsFromBracketRoute(bracket),
+        slots: []
+      };
+    }
+    manifest.layoutPaths.add(rel);
+    manifest.filePathToRoute.set(rel, bracket);
+  }
+  for (const file of appFiles) {
+    const relative = toPosixPath(path.relative(appPath, file));
+    const segments = relative.split("/");
+    let slotIndex = -1;
+    for (let i = segments.length - 1;i >= 0; i--) {
+      if (isSlotSegment(segments[i])) {
+        slotIndex = i;
+        break;
+      }
+    }
+    if (slotIndex === -1)
+      continue;
+    const slotName = segments[slotIndex].slice(1);
+    const ownerDir = segments.slice(0, slotIndex).join("/");
+    if (isPrivate(ownerDir))
+      continue;
+    const ownerRoute = bracketRouteFromDir(ownerDir);
+    const layout = manifest.layoutRoutes[ownerRoute];
+    if (layout && !layout.slots.includes(slotName))
+      layout.slots.push(slotName);
+  }
+  const PAGE_BASENAMES = new Set(PAGE_EXTENSIONS.map((ext) => `page.${ext}`));
+  for (const file of appFiles) {
+    const relative = toPosixPath(path.relative(appPath, file));
+    if (!PAGE_BASENAMES.has(path.basename(relative)))
+      continue;
+    const dir = path.dirname(relative) === "." ? "" : path.dirname(relative);
+    if (isPrivate(dir))
+      continue;
+    const route = bracketRouteFromDir(dir);
+    if (!manifest.appRoutes[route])
+      continue;
+    const rel = relApp(file);
+    manifest.appPagePaths.add(rel);
+    manifest.filePathToRoute.set(rel, route);
+  }
+  const pagesDir = path.join(config.root, "pages");
+  for (const file of await walkFiles(pagesDir)) {
+    const relative = toPosixPath(path.relative(pagesDir, file));
+    if (!PAGE_EXTENSIONS.some((ext) => relative.endsWith(`.${ext}`)))
+      continue;
+    const base = path.basename(relative);
+    if (base.startsWith("_app.") || base.startsWith("_document.") || base.startsWith("_error.")) {
+      continue;
+    }
+    const rel = relApp(file);
+    const isApi = relative === "api" || relative.startsWith("api/");
+    const route = pagesRouteFromRelative(relative);
+    if (isApi) {
+      manifest.pageApiRoutes.add(rel);
+      manifest.filePathToRoute.set(rel, route);
+    } else {
+      manifest.pageRoutes[route] = { path: rel, groups: groupsFromBracketRoute(route) };
+      manifest.pagesRouterPagePaths.add(rel);
+      manifest.filePathToRoute.set(rel, route);
+    }
+  }
+  const redirects = nextConfig.redirects;
+  if (typeof redirects === "function") {
+    const list = await redirects();
+    for (const item of list ?? []) {
+      for (const route of convertCustomRouteSource(item.source)) {
+        manifest.redirectRoutes[route] = { path: route, groups: groupsFromBracketRoute(route) };
+      }
+    }
+  }
+  const rewrites = nextConfig.rewrites;
+  if (typeof rewrites === "function") {
+    const result = await rewrites();
+    const sources = Array.isArray(result) ? result : [...result?.beforeFiles ?? [], ...result?.afterFiles ?? [], ...result?.fallback ?? []];
+    for (const item of sources) {
+      for (const route of convertCustomRouteSource(item.source)) {
+        manifest.rewriteRoutes[route] = { path: route, groups: groupsFromBracketRoute(route) };
+      }
+    }
+  }
+  return manifest;
+}
+
+// src/compat/typed-routes/typegen.ts
+function isDynamicRoute(route) {
+  return /\[.+\]/.test(route);
+}
+function generateRouteTypes(manifest) {
+  const appRoutes = Object.keys(manifest.appRoutes).sort();
+  const pageRoutes = Object.keys(manifest.pageRoutes).sort();
+  const layoutRoutes = Object.keys(manifest.layoutRoutes).sort();
+  const redirectRoutes = Object.keys(manifest.redirectRoutes).sort();
+  const rewriteRoutes = Object.keys(manifest.rewriteRoutes).sort();
+  const appRouteHandlerRoutes = Object.keys(manifest.appRouteHandlerRoutes).sort();
+  const hasAppRouteHandlers = appRouteHandlerRoutes.length > 0;
+  const union = (list) => list.map((route) => JSON.stringify(route)).join(" | ");
+  let result = "";
+  result += appRoutes.length > 0 ? `type AppRoutes = ${union(appRoutes)}
+` : `type AppRoutes = never
+`;
+  if (hasAppRouteHandlers) {
+    result += `type AppRouteHandlerRoutes = ${union(appRouteHandlerRoutes)}
+`;
+  }
+  result += pageRoutes.length > 0 ? `type PageRoutes = ${union(pageRoutes)}
+` : `type PageRoutes = never
+`;
+  result += layoutRoutes.length > 0 ? `type LayoutRoutes = ${union(layoutRoutes)}
+` : `type LayoutRoutes = never
+`;
+  result += redirectRoutes.length > 0 ? `type RedirectRoutes = ${union(redirectRoutes)}
+` : `type RedirectRoutes = never
+`;
+  result += rewriteRoutes.length > 0 ? `type RewriteRoutes = ${union(rewriteRoutes)}
+` : `type RewriteRoutes = never
+`;
+  const routeUnionParts = [
+    "AppRoutes",
+    "PageRoutes",
+    "LayoutRoutes",
+    "RedirectRoutes",
+    "RewriteRoutes"
+  ];
+  if (hasAppRouteHandlers)
+    routeUnionParts.push("AppRouteHandlerRoutes");
+  result += `type Routes = ${routeUnionParts.join(" | ")}
+`;
+  return result;
+}
+function generateParamTypes(manifest) {
+  const allRoutes = {
+    ...manifest.appRoutes,
+    ...manifest.appRouteHandlerRoutes,
+    ...manifest.pageRoutes,
+    ...manifest.layoutRoutes,
+    ...manifest.redirectRoutes,
+    ...manifest.rewriteRoutes
+  };
+  let paramTypes = `interface ParamMap {
+`;
+  const sortedRoutes = Object.entries(allRoutes).sort(([a], [b]) => a.localeCompare(b));
+  for (const [route, routeInfo] of sortedRoutes) {
+    const groups = routeInfo.groups;
+    if (!isDynamicRoute(route) || Object.keys(groups ?? {}).length === 0) {
+      paramTypes += `  ${JSON.stringify(route)}: {}
+`;
+      continue;
+    }
+    let paramType = "{";
+    for (const [key, group] of Object.entries(groups)) {
+      const escapedKey = JSON.stringify(key);
+      if (group.repeat) {
+        paramType += group.optional ? ` ${escapedKey}?: string[];` : ` ${escapedKey}: string[];`;
+      } else {
+        paramType += group.optional ? ` ${escapedKey}?: string;` : ` ${escapedKey}: string;`;
+      }
+    }
+    paramType += " }";
+    paramTypes += `  ${JSON.stringify(route)}: ${paramType}
+`;
+  }
+  paramTypes += `}
+`;
+  return paramTypes;
+}
+function generateLayoutSlotMap(manifest) {
+  let slotMap = `interface LayoutSlotMap {
+`;
+  const sorted = Object.entries(manifest.layoutRoutes).sort(([a], [b]) => a.localeCompare(b));
+  for (const [route, routeInfo] of sorted) {
+    const slots = [...routeInfo.slots].sort();
+    slotMap += slots.length > 0 ? `  ${JSON.stringify(route)}: ${slots.map((slot) => JSON.stringify(slot)).join(" | ")}
+` : `  ${JSON.stringify(route)}: never
+`;
+  }
+  slotMap += `}
+`;
+  return slotMap;
+}
+function formatRouteToRouteType(route) {
+  const isDynamic = isDynamicRoute(route);
+  let routeType = route;
+  if (isDynamic) {
+    routeType = route.split("/").map((part) => {
+      if (part.startsWith("[") && part.endsWith("]")) {
+        if (part.startsWith("[[...") && part.endsWith("]]"))
+          return "${OptionalCatchAllSlug<T>}";
+        if (part.startsWith("[..."))
+          return "${CatchAllSlug<T>}";
+        return "${SafeSlug<T>}";
+      }
+      return part;
+    }).join("/");
+  }
+  return { isDynamic, routeType };
+}
+function serializeRouteTypes(routeTypes) {
+  routeTypes.sort(([a], [b]) => a.localeCompare(b));
+  let union = "";
+  for (const [route, cause] of routeTypes) {
+    union += `
+    | \`${route}\` // ${cause}`;
+  }
+  return union;
+}
+function generateRouteTypesFile(manifest) {
+  const routeTypes = generateRouteTypes(manifest);
+  const paramTypes = generateParamTypes(manifest);
+  const layoutSlotMap = generateLayoutSlotMap(manifest);
+  const hasAppRouteHandlers = Object.keys(manifest.appRouteHandlerRoutes).length > 0;
+  const routeExports = [
+    "AppRoutes",
+    "PageRoutes",
+    "LayoutRoutes",
+    "RedirectRoutes",
+    "RewriteRoutes",
+    "ParamMap"
+  ];
+  if (hasAppRouteHandlers)
+    routeExports.push("AppRouteHandlerRoutes");
+  const exportStatement = `export type { ${routeExports.join(", ")} }`;
+  const routeContextInterface = hasAppRouteHandlers ? `
+
+  /**
+   * Context for Next.js App Router route handlers
+   * @example
+   * \`\`\`tsx
+   * export async function GET(request: NextRequest, context: RouteContext<'/api/users/[id]'>) {
+   *   const { id } = await context.params
+   *   return Response.json({ id })
+   * }
+   * \`\`\`
+   */
+  interface RouteContext<AppRouteHandlerRoute extends AppRouteHandlerRoutes> {
+    params: Promise<ParamMap[AppRouteHandlerRoute]>
+  }` : "";
+  return `// This file is generated automatically by Next.js
+// Do not edit this file manually
+
+${routeTypes}
+
+${paramTypes}
+
+export type ParamsOf<Route extends Routes> = ParamMap[Route]
+
+${layoutSlotMap}
+
+${exportStatement}
+
+declare global {
+  /**
+   * Props for Next.js App Router page components
+   * @example
+   * \`\`\`tsx
+   * export default function Page(props: PageProps<'/blog/[slug]'>) {
+   *   const { slug } = await props.params
+   *   return <div>Blog post: {slug}</div>
+   * }
+   * \`\`\`
+   */
+  interface PageProps<AppRoute extends AppRoutes> {
+    params: Promise<ParamMap[AppRoute]>
+    searchParams: Promise<Record<string, string | string[] | undefined>>
+  }
+
+  /**
+   * Props for Next.js App Router layout components
+   * @example
+   * \`\`\`tsx
+   * export default function Layout(props: LayoutProps<'/dashboard'>) {
+   *   return <div>{props.children}</div>
+   * }
+   * \`\`\`
+   */
+  type LayoutProps<LayoutRoute extends LayoutRoutes> = {
+    params: Promise<ParamMap[LayoutRoute]>
+    searchParams: Promise<Record<string, string | string[] | undefined>>
+    children: React.ReactNode
+  } & {
+    [K in LayoutSlotMap[LayoutRoute]]: React.ReactNode
+  }${routeContextInterface}
+}
+`;
+}
+function generateLinkTypesFile(manifest) {
+  const visited = new Set;
+  const staticRouteTypes = [];
+  const dynamicRouteTypes = [];
+  for (const routeMap of [
+    manifest.appRoutes,
+    manifest.pageRoutes,
+    manifest.redirectRoutes,
+    manifest.rewriteRoutes,
+    manifest.appRouteHandlerRoutes
+  ]) {
+    for (const route in routeMap) {
+      if (visited.has(route))
+        continue;
+      visited.add(route);
+      const { isDynamic, routeType } = formatRouteToRouteType(route);
+      const cause = routeMap[route].path;
+      (isDynamic ? dynamicRouteTypes : staticRouteTypes).push([routeType, cause]);
+    }
+  }
+  for (const filePath of manifest.pageApiRoutes) {
+    if (visited.has(filePath))
+      continue;
+    visited.add(filePath);
+    const { isDynamic, routeType } = formatRouteToRouteType(filePath);
+    (isDynamic ? dynamicRouteTypes : staticRouteTypes).push([routeType, filePath]);
+  }
+  const serializedStaticRouteTypes = serializeRouteTypes(staticRouteTypes);
+  const serializedDynamicRouteTypes = serializeRouteTypes(dynamicRouteTypes);
+  const routeTypesFallback = !serializedStaticRouteTypes && !serializedDynamicRouteTypes ? "string & {}" : "";
+  return `// This file is generated automatically by Next.js
+// Do not edit this file manually
+
+// Type definitions for Next.js routes
+
+/**
+ * Internal types used by the Next.js router and Link component.
+ * These types are not meant to be used directly.
+ * @internal
+ */
+declare namespace __next_route_internal_types__ {
+  type SearchOrHash = \`?\${string}\` | \`#\${string}\`
+  type WithProtocol = \`\${string}:\${string}\`
+
+  type Suffix = '' | SearchOrHash
+
+  type SafeSlug<S extends string> = S extends \`\${string}/\${string}\`
+    ? never
+    : S extends \`\${string}\${SearchOrHash}\`
+    ? never
+    : S extends ''
+    ? never
+    : S
+
+  type CatchAllSlug<S extends string> = S extends \`\${string}\${SearchOrHash}\`
+    ? never
+    : S extends ''
+    ? never
+    : S
+
+  type OptionalCatchAllSlug<S extends string> =
+    S extends \`\${string}\${SearchOrHash}\` ? never : S
+
+  type StaticRoutes = ${serializedStaticRouteTypes || "never"}
+  type DynamicRoutes<T extends string = string> = ${serializedDynamicRouteTypes || "never"}
+
+  type RouteImpl<T> = ${routeTypesFallback || `
+    ${"| StaticRoutes"}
+    | SearchOrHash
+    | WithProtocol
+    | \`\${StaticRoutes}\${SearchOrHash}\`
+    | (T extends \`\${DynamicRoutes<infer _>}\${Suffix}\` ? T : never)
+    `}
+}
+
+declare module 'next' {
+  export { default } from 'next/types.js'
+  export * from 'next/types.js'
+
+  export type Route<T extends string = string> =
+    __next_route_internal_types__.RouteImpl<T>
+}
+
+declare module 'next/link' {
+  export { useLinkStatus } from 'next/dist/client/link.js'
+
+  import type { LinkProps as OriginalLinkProps } from 'next/dist/client/link.js'
+  import type { AnchorHTMLAttributes, DetailedHTMLProps } from 'react'
+  import type { UrlObject } from 'url'
+
+  type LinkRestProps = Omit<
+    Omit<
+      DetailedHTMLProps<
+        AnchorHTMLAttributes<HTMLAnchorElement>,
+        HTMLAnchorElement
+      >,
+      keyof OriginalLinkProps
+    > &
+      OriginalLinkProps,
+    'href'
+  >
+
+  export type LinkProps<RouteInferType> = LinkRestProps & {
+    /**
+     * The path or URL to navigate to. This is the only required prop. It can also be an object.
+     * @see https://nextjs.org/docs/api-reference/next/link
+     */
+    href: __next_route_internal_types__.RouteImpl<RouteInferType> | UrlObject
+  }
+
+  export default function Link<RouteType>(props: LinkProps<RouteType>): JSX.Element
+}
+
+declare module 'next/navigation' {
+  export * from 'next/dist/client/components/navigation.js'
+
+  import type { NavigateOptions, PrefetchOptions, AppRouterInstance as OriginalAppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime.js'
+  import type { RedirectType } from 'next/dist/client/components/redirect-error.js'
+
+  interface AppRouterInstance extends OriginalAppRouterInstance {
+    /**
+     * Navigate to the provided href.
+     * Pushes a new history entry.
+     */
+    push<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>, options?: NavigateOptions): void
+    /**
+     * Navigate to the provided href.
+     * Replaces the current history entry.
+     */
+    replace<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>, options?: NavigateOptions): void
+    /**
+     * Prefetch the provided href.
+     */
+    prefetch<RouteType>(href: __next_route_internal_types__.RouteImpl<RouteType>, options?: PrefetchOptions): void
+  }
+
+  export function useRouter(): AppRouterInstance;
+
+  export function redirect<RouteType>(
+    url: __next_route_internal_types__.RouteImpl<RouteType>,
+    type?: RedirectType
+  ): never;
+
+  export function permanentRedirect<RouteType>(
+    url: __next_route_internal_types__.RouteImpl<RouteType>,
+    type?: RedirectType
+  ): never;
+}
+
+declare module 'next/form' {
+  import type { FormProps as OriginalFormProps } from 'next/dist/client/form.js'
+
+  type FormRestProps = Omit<OriginalFormProps, 'action'>
+
+  export type FormProps<RouteInferType> = {
+    action: __next_route_internal_types__.RouteImpl<RouteInferType> | ((formData: FormData) => void)
+  } & FormRestProps
+
+  export default function Form<RouteType>(props: FormProps<RouteType>): JSX.Element
+}
+`;
+}
+function generateValidatorFile(manifest, toImportSpecifier) {
+  const generateValidations = (paths, type, pathToRouteMap) => paths.sort().filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx")).filter((filePath) => type !== "AppPageConfig" || filePath.endsWith("page.ts") || filePath.endsWith("page.tsx")).map((filePath) => {
+    const importPath = toImportSpecifier(filePath);
+    const route = pathToRouteMap?.get(filePath);
+    const typeWithRoute = route && (type === "AppPageConfig" || type === "LayoutConfig" || type === "RouteHandlerConfig") ? `${type}<${JSON.stringify(route)}>` : type;
+    return `// Validate ${filePath}
+{
+  type __IsExpected<Specific extends ${typeWithRoute}> = Specific
+  const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, ".js"))})
+  type __Check = __IsExpected<typeof handler>
+  // @ts-ignore
+  type __Unused = __Check
+}`;
+  }).join(`
+
+`);
+  const appPageValidations = generateValidations([...manifest.appPagePaths].sort(), "AppPageConfig", manifest.filePathToRoute);
+  const appRouteHandlerValidations = generateValidations([...manifest.appRouteHandlers].sort(), "RouteHandlerConfig", manifest.filePathToRoute);
+  const pagesRouterPageValidations = generateValidations([...manifest.pagesRouterPagePaths].sort(), "PagesPageConfig");
+  const pagesApiRouteValidations = generateValidations([...manifest.pageApiRoutes].sort(), "ApiRouteConfig");
+  const layoutValidations = generateValidations([...manifest.layoutPaths].sort(), "LayoutConfig", manifest.filePathToRoute);
+  const hasAppRouteHandlers = Object.keys(manifest.appRouteHandlerRoutes).length > 0;
+  let typeDefinitions = "";
+  if (appPageValidations) {
+    typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
+  default: React.JSXElementConstructor<PageProps<Route>> | ((props: { params: Promise<ParamMap[Route]>, searchParams: Promise<any> }) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+  }
+  if (pagesRouterPageValidations) {
+    typeDefinitions += `type PagesPageConfig = {
+  default: React.ComponentType<any> | ((props: any) => React.ReactNode | Promise<React.ReactNode> | never | void)
+  getStaticProps?: (context: any) => Promise<any> | any
+  getStaticPaths?: (context: any) => Promise<any> | any
+  getServerSideProps?: (context: any) => Promise<any> | any
+  getInitialProps?: (context: any) => Promise<any> | any
+  /**
+   * Segment configuration for legacy Pages Router pages.
+   * Validated at build-time by parsePagesSegmentConfig.
+   */
+  config?: {
+    maxDuration?: number
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    regions?: string[]
+  }
+}
+
+`;
+  }
+  if (layoutValidations) {
+    typeDefinitions += `type LayoutConfig<Route extends LayoutRoutes = LayoutRoutes> = {
+  default: React.ComponentType<LayoutProps<Route>> | ((props: LayoutProps<Route>) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+  }
+  if (appRouteHandlerValidations) {
+    typeDefinitions += `type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRoutes> = {
+  GET?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  POST?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PUT?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PATCH?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  DELETE?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  HEAD?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  OPTIONS?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+}
+
+`;
+  }
+  if (pagesApiRouteValidations) {
+    typeDefinitions += `type ApiRouteConfig = {
+  default: (req: any, res: any) => ReturnType<NextApiHandler>
+  config?: {
+    api?: {
+      bodyParser?: boolean | { sizeLimit?: number | string }
+      responseLimit?: string | number | boolean
+      externalResolver?: boolean
+    }
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    maxDuration?: number
+  }
+}
+
+`;
+  }
+  const routeImports = [];
+  if (appPageValidations)
+    routeImports.push("AppRoutes");
+  if (layoutValidations)
+    routeImports.push("LayoutRoutes");
+  if (appPageValidations || layoutValidations || appRouteHandlerValidations)
+    routeImports.push("ParamMap");
+  if (hasAppRouteHandlers)
+    routeImports.push("AppRouteHandlerRoutes");
+  const routeImportStatement = routeImports.length > 0 ? `import type { ${routeImports.join(", ")} } from "./routes.js"` : "";
+  const nextRequestImport = hasAppRouteHandlers ? `import type { NextRequest } from 'next/server.js'
+` : "";
+  const nextTypes = [];
+  if (pagesApiRouteValidations)
+    nextTypes.push("NextApiHandler");
+  if (appPageValidations || layoutValidations)
+    nextTypes.push("ResolvingMetadata", "ResolvingViewport");
+  const nextTypesImport = nextTypes.length > 0 ? `import type { ${nextTypes.join(", ")} } from "next/types.js"
+` : "";
+  return `// This file is generated automatically by Next.js
+// Do not edit this file manually
+// This file validates that all pages and layouts export the correct types
+
+${routeImportStatement}
+${nextTypesImport}${nextRequestImport}
+${typeDefinitions}
+${appPageValidations}
+
+${appRouteHandlerValidations}
+
+${pagesRouterPageValidations}
+
+${pagesApiRouteValidations}
+
+${layoutValidations}
+`;
+}
+
+// src/compat/typed-routes/generate.ts
+async function writeIfChanged(file, source) {
+  if (existsSync2(file) && await readFile(file, "utf8") === source)
+    return;
+  await ensureDir(path2.dirname(file));
+  await writeFile(file, source);
+}
+async function generateTypedRoutes(config, routes) {
+  const nextConfig = getNextConfig();
+  const typedRoutes = nextConfig.typedRoutes === true;
+  const manifest = await buildRouteTypesManifest({ config, routes, nextConfig });
+  const typesDir = path2.join(config.root, ".next", "types");
+  await writeIfChanged(path2.join(typesDir, "routes.d.ts"), generateRouteTypesFile(manifest));
+  const toImportSpecifier = (rootRelativePath) => {
+    const abs = path2.join(config.root, rootRelativePath);
+    const rel = toPosixPath(path2.relative(typesDir, abs));
+    return rel.startsWith(".") ? rel : `./${rel}`;
+  };
+  await writeIfChanged(path2.join(typesDir, "validator.ts"), generateValidatorFile(manifest, toImportSpecifier));
+  if (typedRoutes) {
+    await writeIfChanged(path2.join(typesDir, "link.d.ts"), generateLinkTypesFile(manifest));
+  }
+  await writeIfChanged(path2.join(typesDir, "root-params.d.ts"), rootParamsTypesFile(scanRootParamTypes(path2.join(config.root, "app"))));
+  await writeNextEnv(config.root, typedRoutes);
+}
+function rootParamsTypesFile(rootParams) {
+  if (rootParams.size === 0) {
+    return `// Type definitions for Next.js root params (next/root-params)
+// No root params detected.
+export {}
+`;
+  }
+  const order = ["string", "string[]", "undefined"];
+  const getters = [...rootParams.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, types]) => {
+    const union = order.filter((type) => types.has(type)).join(" | ");
+    return `  export function ${name}(): Promise<${union}>`;
+  });
+  return `// Type definitions for Next.js root params (next/root-params)
+
+declare module 'next/root-params' {
+${getters.join(`
+`)}
+}
+`;
+}
+async function writeNextEnv(root, typedRoutes) {
+  const lines = [
+    '/// <reference types="next" />',
+    'import "./.next/types/routes.d.ts";',
+    'import "./.next/types/root-params.d.ts";'
+  ];
+  if (typedRoutes)
+    lines.push('import "./.next/types/link.d.ts";');
+  lines.push("", "// NOTE: This file should not be edited", "");
+  await writeIfChanged(path2.join(root, "next-env.d.ts"), lines.join(`
+`));
+}
+
+export { generateTypedRoutes };