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

package/dist/project.d.ts

@@ -0,0 +1,264 @@
+import { NextBuild } from "./build.js";
+import { RoutesManifest } from "./compat/types.js";
+import { FlightEntry } from "./flight.js";
+import { PageEnv } from "./project/env.js";
+import { NewExport } from "./node-platform.js";
+import { WebpackRule } from "./project/webpack.js";
+import { ResolveRoutesParams } from "@next/routing";
+import * as _$vite from "vite";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/project.d.ts
+/** The layers Next compiles an App Router app into, each with its own React. */
+type NextLayer = "rsc" | "ssr" | "browser";
+type NextRoute = {
+  /** What serves the route: a `page.tsx` with its layouts, or a `route.ts`. */kind: "page" | "route"; /** App page name, e.g. `/notes/[id]/page` or `/api/notes/[id]/route`. */
+  page: string; /** Routable pathname, e.g. `/notes/[id]`. */
+  pathname: string; /** `private-next-app-dir/...`, or an absolute path for Next's builtin pages. */
+  pagePath: string; /** The pages of the route: `page`, and those of its parallel routes. */
+  appPaths: string[];
+};
+/** A route of a node, see `NextProject.componentRoutes`. */
+type ComponentRoute = {
+  kind: "page";
+  /**
+   * Its page name, e.g. `/notes/[id]/page`, from which Next takes its params
+   * and the tags of its path. `revalidatePath("/notes/[id]", "page")` expires
+   * the cached reads with those tags. A page of the app can have the same
+   * name.
+   */
+  page: string; /** Routable pathname, e.g. `/notes/[id]`. */
+  pathname: string; /** What its modules are listed by, which no page of the app has as its name. */
+  component: string;
+  /**
+   * With the layouts of the app's route `page`: the node is the page of that
+   * route, in its layouts and with its `loading`, `error` and `not-found`.
+   */
+  layouts?: true;
+};
+/**
+ * What the server in front of the app goes by: the routes that Next's build
+ * hands a deployment adapter, as `resolveRoutes()` of `@next/routing` takes
+ * them.
+ */
+type NextRouting = Pick<ResolveRoutesParams, "routes" | "basePath" | "buildId"> & {
+  /**
+   * What the build has to answer a request with, by the pathname Next serves
+   * it at, like `/notes/[id]`: the page name of its route.
+   */
+  outputs: Record<string, string>;
+  /**
+   * The routes of the app alone, without the server in front of it: no
+   * redirect, rewrite or header of `next.config`, and no middleware. What is
+   * left is Next's own: the routes of the app, its interception routes, and
+   * the headers it adds once it has a route.
+   */
+  appRoutes: ResolveRoutesParams["routes"];
+};
+type NextProject = {
+  root: string;
+  appDir: string; /** Directory of the installed `next` package. */
+  nextDir: string; /** Version of the installed `next` package. */
+  version: string;
+  routes: NextRoute[];
+  /**
+   * The routes `renderServer(<Node />, { url })` renders a node in: one for
+   * each pathname of the app, so that a URL has the params of the app's route,
+   * and one for `/`, for a node without a url or with a URL of no route.
+   */
+  componentRoutes: ComponentRoute[]; /** The route files of the app that ask for Next's edge runtime, which they do not get. */
+  edgeRouteFiles: string[];
+  /**
+   * The dynamic routes that `resolveRoutes()` does not find for a request: the
+   * ones under a folder with a name that a URL percent-encodes.
+   */
+  unmatchedRoutes: string[];
+  /**
+   * The exports of Next's modules that their stand-ins in node-platform.ts
+   * have not, by the stand-in: new in the installed Next.
+   */
+  newExports: Record<string, NewExport[]>; /** The `proxy.ts` of the app, or its `middleware.ts`: its file, if it has one. */
+  middlewareFile: string | undefined; /** What the server does with a request before a route gets it. */
+  routing: NextRouting;
+  /**
+   * The page name of the route the server answers a URL with, as nothing has
+   * run, without headers or cookies: with `proxy`, after the redirects and
+   * rewrites of `next.config`, and the middleware takes every request on as it
+   * is. Nothing for a URL of no route, or one that a redirect sends to another
+   * origin.
+   */
+  pageOf(url: URL, options: {
+    proxy: boolean;
+  }): Promise<string | undefined>; /** What a build writes to `.next/routes-manifest.json`, which Next's route module reads. */
+  routesManifest: RoutesManifest; /** The keys of draft mode, which a build makes and writes to `.next/`. */
+  preview: {
+    previewModeId: string;
+    previewModeSigningKey: string;
+    previewModeEncryptionKey: string;
+  };
+  /**
+   * The `paths` of the app's tsconfig or jsconfig, as Next's build reads
+   * them, and the directory they are from. Nothing for an app without either.
+   */
+  paths: {
+    baseUrl: string;
+    explicitBaseUrl: boolean;
+    patterns: Record<string, string[]>;
+  } | undefined; /** What the page's `process.env` gets: see project/env.ts. */
+  env: PageEnv; /** The env again, after a change of an env file. */
+  loadEnv: () => Promise<PageEnv>; /** The resolved `next.config`, as far as it serializes. */
+  config: Record<string, unknown>; /** Next's compile-time constants per layer, as code strings. */
+  defines: Record<NextLayer, Record<string, string>>; /** Next's compiler aliases per layer, in webpack's notation: `$` ends an exact match. */
+  aliases: Record<NextLayer, Record<string, string | false>>;
+  /**
+   * Entries that the app's code, and not Next's own files, gets in place of
+   * those of `aliases`: React's for Node.js. Exact matches, `$`.
+   */
+  appAliases: Record<NextLayer, Record<string, string>>;
+  /**
+   * The exports of each entry of the Flight codec that the rsc layer imports
+   * as `react-server-dom-webpack/<entry>`.
+   */
+  flightExports: Record<FlightEntry, string[]>;
+  /**
+   * The rsc-layer module of a route, from Next's app loader, with this
+   * package's runtime where Next's code names its bundler. For a page: its
+   * loader tree and `entry-base`. For a route handler: its route module.
+   *
+   * For a route of a node: Next's page template around a loader tree that has
+   * the segments of the pathname, and the node as its page. Nothing of the app.
+   */
+  loadRouteEntry(route: NextRoute | ComponentRoute): Promise<{
+    code: string;
+    watchFiles: string[];
+    /**
+     * The files of the segments of a page route, as its entry imports them:
+     * its layouts, pages and boundaries. Not the node of the route of a node,
+     * which is no file: its name in the loader tree is `componentPagePath`.
+     */
+    segments: RouteSegment[];
+  }>;
+  /**
+   * Next's request handler of the middleware: its template around the file.
+   * Nothing for an app without one.
+   */
+  loadMiddlewareEntry(): Promise<string | undefined>;
+  /**
+   * Next's SWC transform of a module of the app, for a layer. Nothing for a
+   * client module in the rsc layer: Vite RSC turns it into references.
+   */
+  compile(code: string, file: string, layer: NextLayer): Promise<Compiled | undefined>;
+  /**
+   * The options of that transform for a dependency of a layer, like a package
+   * that calls `next/font`: from `next.config` and the app's tsconfig. For the
+   * key of the optimizer's cache, which compiles such a package.
+   */
+  dependencyCompileOptions: Record<NextLayer, unknown>;
+  /**
+   * The rule of the `webpack` function in `next.config` for a file, like the
+   * one of `@next/mdx` for an `.mdx` file: see project/webpack.ts.
+   */
+  webpackRuleOf(file: string, layer: NextLayer): WebpackRule | undefined; /** What the loaders of that rule make of the file. Nothing for a file without one. */
+  loadWithWebpackRule(file: string, layer: NextLayer): Promise<string | undefined>; /** The candidates of an alias of the `webpack` function for an import, in order. */
+  webpackAliasOf(source: string, layer: NextLayer): string[] | undefined; /** The packages among those candidates, to pre-bundle. */
+  webpackPackages: Record<NextLayer, string[]>; /** What of the `webpack` function does not apply, to say when a run starts. */
+  webpackDifferences: string[];
+  /**
+   * Whether an import is Next's inline request for one of its metadata
+   * loaders, which its app loader asks for a metadata file of the app with.
+   */
+  isMetadataRequest(source: string): boolean;
+  /**
+   * What a metadata loader makes of a file: for a page, the data of an image
+   * it links in its head, like `icon.png`; for a route, its route module.
+   */
+  loadMetadata(request: string): Promise<{
+    code: string;
+    watchFiles: string[];
+  }>;
+  /**
+   * The query with which the module of a generated image, like `icon.tsx`,
+   * is imported for what it says of the image: its `size`, `alt`,
+   * `contentType` and `generateImageMetadata`.
+   */
+  metadataImageMeta: string; /** Whether Next's build imports a file as an image: `next-image-loader`. */
+  isImage(file: string): boolean; /** The module of an image: what `next-image-loader` makes of the file. */
+  loadImage(file: string): Promise<string>;
+  /**
+   * A call of a `next/font` function, by the import the SWC transform turns it
+   * into: the CSS of the font, what the call returns, and its font files,
+   * under `/_next/` (`static/media/…`). Next preloads a file whose name has
+   * `.p.`, which the loader gives it for a font with `preload` on.
+   */
+  loadFont(request: string): Promise<{
+    css: string;
+    exports: Record<string, unknown>;
+    files: string[];
+  }>;
+  /**
+   * What Next's rules for CSS decide that is not bundling: its PostCSS
+   * plugins and the class names of a CSS module, as Vite's options.
+   */
+  loadCssOptions(): Promise<{
+    options: _$vite.CSSOptions; /** What is done otherwise than Next's build does it, to say when a run starts. */
+    differences: string[];
+  }>;
+  /**
+   * Where the browser asks for the files of the app: `/_next/`, after an
+   * asset prefix that is a path.
+   */
+  assetPath: string; /** A file the loaders emitted for the browser, by the path the browser asks for. */
+  readEmittedFile(pathname: string): {
+    body: Buffer;
+    contentType: string;
+  } | undefined; /** The files the loaders have emitted so far, for a static build to write. */
+  emittedFiles(): {
+    pathname: string;
+    body: Buffer;
+  }[];
+  /**
+   * Answers a request for `/_next/image` with Next's image optimizer, as
+   * `next start` does, and resolves with whether it was one. `serveFile`
+   * answers the request for an image of the app.
+   */
+  optimizeImage(request: IncomingMessage, response: ServerResponse, serveFile: ServeFile): Promise<boolean>; /** The module that Next's build makes of `next/root-params`, for the app. */
+  loadRootParams(): Promise<string>;
+};
+/** A file of a segment of a page route: see `loadRouteEntry()`. */
+type RouteSegment = {
+  /** The file, by its absolute path, which the entry imports. */file: string;
+  /**
+   * What Next looks up the stylesheets of the segment by: the name the loader
+   * tree has for the file, without its extension. The name is the path from
+   * the root of the project, the same on every machine and with a dev server
+   * or a build: see `nameInLoaderTree()` in project/entries.ts.
+   */
+  stylesheetsKey: string;
+};
+/**
+ * What Next's compiler makes of a module. `refused` where it stops at the
+ * module, as `next build` does, like a client hook in a Server Component:
+ * then the code throws Next's error.
+ */
+type Compiled = {
+  code: string;
+  map?: string;
+  refused?: true;
+};
+/** Answers a request the way the server does: what Next calls for an image of the app. */
+type ServeFile = (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+type NextProjectOptions = {
+  /** The code that Next's runtime and React run: see build.ts. */build?: NextBuild;
+  /**
+   * For a static build, which has no server next to the browser: what the server
+   * outside the browser does, the app does without. That is Next's image
+   * optimizer, so `next/image` asks for the image itself.
+   */
+  static?: boolean;
+};
+declare function loadNextProject(root: string, projectRequire?: NodeJS.Require, {
+  build,
+  static: isStatic
+}?: NextProjectOptions): Promise<NextProject>;
+//#endregion
+export { Compiled, ComponentRoute, NextLayer, NextProject, NextProjectOptions, NextRoute, NextRouting, RouteSegment, ServeFile, loadNextProject };

package/dist/project.js

@@ -0,0 +1,58 @@
+import { openNextProject } from "./project/context.js";
+import { routeEntries } from "./project/entries.js";
+import { layerTables } from "./project/layers.js";
+import { createLoaders } from "./project/loaders.js";
+import { createMetadataLoaders } from "./project/metadata.js";
+import { discoverAppRoutes } from "./project/routes.js";
+import { buildRouting, findMiddleware } from "./project/routing.js";
+import { checkRuntime } from "./compat/checks.js";
+import { createCompiler } from "./project/transform.js";
+import { createWebpackRules } from "./project/webpack.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/project.ts
+const adapterPath = fileURLToPath(new URL(`./adapter${path.extname(import.meta.url)}`, import.meta.url));
+const envWorker = fileURLToPath(new URL(`./project/env-worker${path.extname(import.meta.url)}`, import.meta.url));
+async function loadNextProject(root, projectRequire = createRequire(path.join(root, "package.json")), { build = "development", static: isStatic = false } = {}) {
+	const context = await openNextProject(root, projectRequire, {
+		static: isStatic,
+		envWorker
+	});
+	const app = await discoverAppRoutes(context);
+	const middleware = await findMiddleware(context);
+	const { routing, routesManifest, unmatchedRoutes, pageOf } = await buildRouting(context, app, middleware, adapterPath);
+	const { builtinBoundaries, newExports } = checkRuntime(context);
+	const layers = await layerTables(context, build);
+	const compiler = await createCompiler(context);
+	const { runLoader, ...loaders } = createLoaders(context, build);
+	return {
+		root,
+		appDir: context.appDir,
+		nextDir: context.nextDir,
+		version: context.version,
+		routes: app.routes,
+		edgeRouteFiles: app.edgeRouteFiles,
+		unmatchedRoutes,
+		newExports,
+		middlewareFile: middleware.middlewareFile,
+		routing,
+		pageOf,
+		routesManifest,
+		preview: context.previewProps,
+		env: context.env,
+		loadEnv: context.loadEnv,
+		config: JSON.parse(JSON.stringify({
+			...context.config,
+			env: Object.fromEntries(Object.keys(context.config.env).map((name) => [name, context.env.values[name]]))
+		})),
+		...layers,
+		...routeEntries(context, app, middleware, builtinBoundaries, runLoader),
+		...compiler,
+		...loaders,
+		...createWebpackRules(context, runLoader),
+		...createMetadataLoaders(context, runLoader)
+	};
+}
+//#endregion
+export { loadNextProject };

package/dist/registry-global.d.ts

@@ -0,0 +1,5 @@
+//#region src/registry-global.d.ts
+/** The global the registry is on. */
+declare const registryGlobal = "__vitest_plugin_rsc_next__";
+//#endregion
+export { registryGlobal };

package/dist/registry-global.js

@@ -0,0 +1,5 @@
+//#region src/registry-global.ts
+/** The global the registry is on. */
+const registryGlobal = "__vitest_plugin_rsc_next__";
+//#endregion
+export { registryGlobal };

package/dist/registry.d.ts

@@ -0,0 +1,241 @@
+import { Stylesheets } from "./styles-shared.js";
+import { SpeedFeatures } from "./mode.js";
+import { SequentialAsyncLocalStorage } from "@kasperpeulen/vitest-plugin-rsc/internal/async-local-storage";
+
+//#region src/registry.d.ts
+type ServerRequest = {
+  url: string;
+  method: string;
+  headers: Headers;
+  body?: ReadableStream<Uint8Array> | Uint8Array | null;
+  signal?: AbortSignal;
+};
+/**
+ * The request handler Next's build makes for a route, for Node.js: it takes
+ * an `http.IncomingMessage` and writes to an `http.ServerResponse`.
+ */
+type RequestHandler = (req: unknown, res: unknown, context: {
+  waitUntil?: (promise: Promise<unknown>) => void;
+  requestMeta?: object;
+}) => Promise<unknown>;
+/**
+ * The request handler Next's build makes for the middleware of an app, its
+ * `proxy.ts`: it takes a `Request` and answers with a `Response`, on Node.js
+ * too.
+ */
+type MiddlewareHandler = (request: ServerRequest, context: {
+  waitUntil?: (promise: Promise<unknown>) => void;
+  signal?: AbortSignal;
+}) => Promise<Response>;
+type AnyFunction = (...args: any[]) => any;
+/**
+ * Which pathnames of a route `next build` prerenders, from its
+ * `generateStaticParams`, before it renders one: see prerender-verdict.ts.
+ */
+type PrerenderVerdict = {
+  /** The pathnames the build prerenders. */pathnames: string[];
+  /**
+   * For a route with params: what Next does for a pathname not among them,
+   * the `fallback` of its prerender manifest. `null` prerenders it at its
+   * first request, `false` answers that it is not found.
+   */
+  fallback?: null | false;
+};
+/** See `NextRegistry.opened`. */
+type Opened = {
+  pathname: string; /** Whether the server in front of the app takes the request: proxy.ts and `next.config`. */
+  proxy: boolean;
+  /**
+   * With `files`: the files of the host that render the node, `hostFiles` of
+   * `renderServer()`. With `version`: which render of it the server sends,
+   * which `rerender()` counts up, and the page says it has committed. The
+   * server reads both as it renders, after `rerender()` has set them.
+   */
+  node?: {
+    ui: unknown;
+    layouts: boolean;
+    files: string[];
+    version?: number;
+  };
+  /**
+   * Whether Next renders the page a Server Action redirects to, into the
+   * response of the action, as Next's router shows that page next. Not for
+   * `runInServerAction()`, which shows no page. Read from `openedByRequest`.
+   */
+  rendersRedirect?: boolean;
+  /**
+   * `false`: Next renders no HTML of the page, see `RenderServerOptions.ssr`.
+   * Read from `openedByRequest`.
+   */
+  ssr?: boolean;
+};
+/**
+ * When a request of the page reached the server, started, was answered and
+ * was done, by `performance.now()`: see `NextRegistry.requestTimings`.
+ */
+type RequestTiming = {
+  method: string;
+  url: string;
+  /**
+   * Whether it is a Server Action, a request of Next's router for Flight, or
+   * a page load: of a document, or of a page of the kept app by its Flight
+   * payload, with `flightLoads`.
+   */
+  kind: "action" | "flight" | "page";
+  queued: number;
+  started?: number;
+  answered?: number;
+  finished?: number;
+};
+type NextRegistry = {
+  /** The speed features that are on, `mode` and the options of the features resolved: see speed-features.ts. */speedFeatures?: SpeedFeatures;
+  /**
+   * For a profile of a test run: set to an array, the server adds the timing
+   * of each request of the page to it, in the order they reached it.
+   */
+  requestTimings?: RequestTiming[]; /** A `Request` and `Response` that keep the headers a browser drops. */
+  Request: typeof Request;
+  Response: typeof Response; /** The `Headers` of those. */
+  Headers: typeof Headers; /** The server's `fetch`: its network, which is not the browser's. */
+  fetch: typeof fetch; /** The network itself: no request of it is the app's, and Next caches none. */
+  network: typeof fetch; /** Node's, for Next's server: a task after the microtasks. Not globals. */
+  setImmediate(callback: (...args: any[]) => void, ...args: unknown[]): unknown;
+  clearImmediate(id: unknown): void; /** The `setTimeout` and `clearTimeout` of server code: see globals.ts. */
+  setTimeout(callback: unknown, delay?: number, ...args: unknown[]): unknown;
+  clearTimeout(id: unknown): void; /** Starts the scope of one request, see `enterAmbientScope`. Returns its end. */
+  enterRequestScope(): () => void; /** What an async function of server code is compiled to call: server-code.ts. */
+  asyncFunctionHooks: object; /** The server's `queueMicrotask`: the callback has the stores of the code that queued it. */
+  queueMicrotask(callback: () => void): void; /** Does a step of a render of React's Flight server, with the stores of its first step. */
+  performWork(request: object, performWork: (request: object) => void): void; /** Changes when the caches are reset. A part of every key of a cache, see cache.ts. */
+  cacheGeneration(): number; /** The rsc layer's Flight codec, behind the signatures Next calls. */
+  flightServer: Record<string, AnyFunction>;
+  flightStatic: Record<string, AnyFunction>;
+  flightClient: Record<string, AnyFunction>; /** Loads the rsc-layer module of a route, into `appPages`. */
+  loadAppPage(page: string): Promise<unknown>;
+  appPages: Record<string, unknown>;
+  /**
+   * Asks the plugin for the stylesheets of a page route, by the name of its
+   * modules, and for the route of a node with `files`, the files of the host
+   * that render the node, `hostFiles` of `renderServer()`: see styles.ts.
+   * The dev server answers; a static build reads them from a file of its
+   * own (rsc.ts).
+   */
+  loadStylesheets(entry: string, inline: boolean, files: string[]): Promise<Stylesheets>;
+  /**
+   * Has the browser start the files of a page route at once, for a page load
+   * that the plugin opens, by what `loadStylesheets()` takes: its modules and
+   * its stylesheets (rsc.ts). They go with the page (document.ts), and none
+   * come once `signal`, the request's, has aborted: the page is gone. Only a
+   * static build has them: a dev server serves a module where it is asked for.
+   * Resolves once they are in the document, before the route loads: Vite
+   * preloads a module that is imported, for good, unless a link has it.
+   */
+  preloadRoute(entry: string, files: string[], signal: AbortSignal | undefined): Promise<void>;
+  /**
+   * Internal, not an API: the Vitest default behind `hostFiles` of
+   * `renderServer()`, the files of the host that render a node when it is
+   * not passed. The setup files and the test file, which the plugin's setup
+   * file sets before every test file (setup.ts). Another host passes
+   * `hostFiles`; without it a node has no stylesheets of the host's files.
+   */
+  nodeFiles?(): string[];
+  /**
+   * Internal, not an API: tells the dev server that the test file of the
+   * tab opened a route, by the name of its modules, which it compiles ahead
+   * when the file runs again (routes-ahead.ts). Set by the plugin's setup
+   * file (setup.ts): another host has no test files.
+   */
+  routeOpened?(entry: string): void; /** The directory of the build on the server's disk, of this generation: see cache.ts. */
+  buildDir(): string;
+  /**
+   * The directory of the server's own files, which the page's host has:
+   * `""` in a browser, a temporary directory in Node.js (page-host.ts).
+   */
+  serverDir(): string;
+  /**
+   * Next's build's verdict on a route of the app, by its page name and its
+   * pathname, in the rsc layer: nothing for a route it renders at every
+   * request.
+   */
+  prerenderVerdict(route: {
+    kind: "page" | "route";
+    page: string;
+    pathname: string;
+  }): Promise<PrerenderVerdict | undefined>; /** Whether an error is the one Next's handler of a route throws for a pathname it does not serve. */
+  isNoFallbackError(error: unknown): boolean; /** Loads the request handler of a route handler, which is in the rsc layer. */
+  loadRouteHandler(page: string): Promise<RequestHandler>; /** Loads the request handler of the middleware of the app, which is in the rsc layer. */
+  loadMiddleware(): Promise<MiddlewareHandler>; /** Whether an id names a Server Action of the app, in the rsc layer. */
+  hasServerAction(id: string): Promise<boolean>;
+  /**
+   * The id of the plugin's own Server Action, which every app here has: the
+   * one of `runInServerAction()`, in the rsc layer.
+   */
+  ownServerAction?: Promise<string | undefined>; /** What the Server Action of `runInServerAction()` runs, by the number it is called with. */
+  serverActions: Map<number, () => Promise<void>>;
+  /**
+   * What a request opened, for as long as it is handled: what it brings for
+   * itself, like the route of a node of `runInServerAction()`, or else
+   * `opened` at its URL (`openedAt()`). The page of the route of a node reads
+   * it, and else `opened`. The server's `fetch` reads its `rendersRedirect`,
+   * and Next's renderer its `ssr`.
+   */
+  openedByRequest: SequentialAsyncLocalStorage<Opened | undefined>;
+  /**
+   * What `renderServer()` opened, for as long as it is open: the pathname of
+   * its URL, and how the server takes a request to that pathname. Without
+   * `proxy` it goes straight to the app's route for it. With a `node`, that
+   * pathname is the node's route, or with `layouts` the app's route with the
+   * node as its page.
+   */
+  opened: Opened | undefined; /** Loads a Client Component by its module id, in the ssr layer. */
+  loadSsrModule(id: string): Promise<unknown>;
+  /**
+   * `__webpack_require__` for the Flight client of the browser layer: loads a
+   * Client Component by its module id, in that layer. One for every page.
+   */
+  browserRequire(id: string): Promise<unknown>;
+  /**
+   * Loads a Client Component by its module id, in the browser layer: the
+   * loader of the page that started last, until it is left.
+   */
+  loadBrowserModule?(id: string): Promise<unknown>;
+  /**
+   * Set while the browser layer gives the router of the kept app of `keepApp`
+   * the state of its next page, which Next's patched router reads: see
+   * `nextPatches` in compat/patches.ts.
+   */
+  replacingRouter?: boolean;
+  /**
+   * Next's route module for a page, loaded in the ssr layer, for the rsc
+   * layer: its class, its renderer, and the contexts of its
+   * `*.shared-runtime` modules.
+   */
+  ssr: {
+    AppPageRouteModule: new (options: unknown) => unknown;
+    vendored: Record<string, unknown>;
+    renderToHTMLOrFlight: AnyFunction;
+    prerenderToHTMLOrFlight: AnyFunction;
+  }; /** For Next's Node.js server: what stands in for the files of a build. */
+  node: Record<string, AnyFunction>;
+};
+declare const registry: NextRegistry;
+/**
+ * What the browser layer loads with no page to load it in: nothing, ever, as
+ * the closed runner of a page that was left.
+ */
+declare const loadsNothing: () => Promise<never>;
+/**
+ * What `renderServer()` opened, at a URL that belongs to it: one with its
+ * pathname. That is the document, and what the page sends there while it is
+ * open: a Server Action, `router.refresh()`, a change of search params. A URL
+ * with another pathname is the app's, as always. The server and the browser
+ * layer both ask, so they agree on it.
+ */
+declare function openedAt(url: URL): Opened | undefined;
+/**
+ * Next's build gives the module of a Server Action an id. Here the id of the
+ * action already says where it is, so the module id is the action id, marked.
+ */
+declare const actionModulePrefix = "action:";
+//#endregion
+export { MiddlewareHandler, NextRegistry, Opened, PrerenderVerdict, RequestHandler, RequestTiming, ServerRequest, actionModulePrefix, loadsNothing, openedAt, registry };

package/dist/registry.js

@@ -0,0 +1,30 @@
+import { registryGlobal } from "./registry-global.js";
+//#region src/registry.ts
+const scope = globalThis;
+const registry = scope[registryGlobal] ??= {
+	appPages: {},
+	serverActions: /* @__PURE__ */ new Map()
+};
+/**
+* What the browser layer loads with no page to load it in: nothing, ever, as
+* the closed runner of a page that was left.
+*/
+const loadsNothing = () => new Promise(() => {});
+/**
+* What `renderServer()` opened, at a URL that belongs to it: one with its
+* pathname. That is the document, and what the page sends there while it is
+* open: a Server Action, `router.refresh()`, a change of search params. A URL
+* with another pathname is the app's, as always. The server and the browser
+* layer both ask, so they agree on it.
+*/
+function openedAt(url) {
+	const { opened } = registry;
+	return opened?.pathname === url.pathname ? opened : void 0;
+}
+/**
+* Next's build gives the module of a Server Action an id. Here the id of the
+* action already says where it is, so the module id is the action id, marked.
+*/
+const actionModulePrefix = "action:";
+//#endregion
+export { actionModulePrefix, loadsNothing, openedAt, registry };

package/dist/route-chunks.d.ts

@@ -0,0 +1,13 @@
+import { Rolldown } from "vite";
+
+//#region src/route-chunks.d.ts
+/**
+ * For each route, by the ids of the modules it loads first, its entry and
+ * what its loader tree imports: the files of their chunks, the entry's first,
+ * and of every chunk those import, but none that `lists` and what they import
+ * are in, which the page has before it loads a route. Not the chunk of a
+ * module that one of them imports with `import()`: that is the app's to load.
+ */
+declare function routeChunksOf(bundle: Rolldown.OutputBundle, lists: string[], routes: Iterable<[route: string, ids: string[]]>): Map<string, string[]>;
+//#endregion
+export { routeChunksOf };

package/dist/route-chunks.js

@@ -0,0 +1,32 @@
+//#region src/route-chunks.ts
+/**
+* For each route, by the ids of the modules it loads first, its entry and
+* what its loader tree imports: the files of their chunks, the entry's first,
+* and of every chunk those import, but none that `lists` and what they import
+* are in, which the page has before it loads a route. Not the chunk of a
+* module that one of them imports with `import()`: that is the app's to load.
+*/
+function routeChunksOf(bundle, lists, routes) {
+	const chunkOf = /* @__PURE__ */ new Map();
+	for (const output of Object.values(bundle)) {
+		if (output.type !== "chunk") continue;
+		for (const id of output.moduleIds) chunkOf.set(id, output);
+	}
+	const chunksOf = (ids, had = /* @__PURE__ */ new Set()) => {
+		const loaded = /* @__PURE__ */ new Set();
+		const visit = (chunk) => {
+			if (!chunk || had.has(chunk.fileName) || loaded.has(chunk.fileName)) return;
+			loaded.add(chunk.fileName);
+			for (const fileName of chunk.imports) {
+				const imported = bundle[fileName];
+				if (imported?.type === "chunk") visit(imported);
+			}
+		};
+		ids.forEach((id) => visit(chunkOf.get(id)));
+		return loaded;
+	};
+	const had = chunksOf(lists);
+	return new Map(Array.from(routes, ([route, ids]) => [route, [...chunksOf(ids, had)]]));
+}
+//#endregion
+export { routeChunksOf };