vinext 0.0.50 → 0.0.52

package/dist/server/default-global-error-module.js

@@ -0,0 +1,20 @@
+import DefaultGlobalError from "../shims/default-global-error.js";
+//#region src/server/default-global-error-module.ts
+/**
+* Module-shaped wrapper around vinext's built-in default global error
+* component. Used as the fallback when an app does not define its own
+* `app/global-error.tsx`. The runtime treats any `{ default: Component }`
+* record as a "global error module", so wrapping the component this way lets
+* us thread the default through the existing `globalErrorModule` plumbing
+* without introducing a parallel code path.
+*
+* Mirrors Next.js's `defaultGlobalErrorPath`
+* (`next/dist/client/components/builtin/global-error.js`), which is selected
+* automatically when the user has not supplied a custom global error file:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+*/
+const DEFAULT_GLOBAL_ERROR_MODULE = { default: DefaultGlobalError };
+//#endregion
+export { DEFAULT_GLOBAL_ERROR_MODULE };
+
+//# sourceMappingURL=default-global-error-module.js.map

package/dist/server/default-global-error-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-global-error-module.js","names":[],"sources":["../../src/server/default-global-error-module.ts"],"sourcesContent":["import DefaultGlobalError from \"vinext/shims/default-global-error\";\n\n/**\n * Module-shaped wrapper around vinext's built-in default global error\n * component. Used as the fallback when an app does not define its own\n * `app/global-error.tsx`. The runtime treats any `{ default: Component }`\n * record as a \"global error module\", so wrapping the component this way lets\n * us thread the default through the existing `globalErrorModule` plumbing\n * without introducing a parallel code path.\n *\n * Mirrors Next.js's `defaultGlobalErrorPath`\n * (`next/dist/client/components/builtin/global-error.js`), which is selected\n * automatically when the user has not supplied a custom global error file:\n * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts\n */\nexport const DEFAULT_GLOBAL_ERROR_MODULE = {\n  default: DefaultGlobalError,\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,8BAA8B,EACzC,SAAS,oBACV"}

package/dist/server/dev-lockfile.d.ts

@@ -0,0 +1,110 @@
+//#region src/server/dev-lockfile.d.ts
+/**
+ * Dev server lock file.
+ *
+ * Writes the running dev server's PID, port, and URL into a lock file at
+ * `<root>/.vinext/dev/lock.json`. When a second `vinext dev` process starts in
+ * the same project directory, it reads the lock file and either fails with an
+ * actionable error or, if the previous process is dead, takes over the lock.
+ *
+ * This is especially useful for AI coding agents, which frequently attempt to
+ * start `vinext dev` without knowing a server is already running.
+ *
+ * Ported behaviorally from Next.js:
+ *   https://github.com/vercel/next.js/blob/canary/packages/next/src/build/lockfile.ts
+ *
+ * Differences vs Next.js:
+ * - No native `flock()`. Next.js uses Rust SWC bindings for cross-platform
+ *   advisory locking; vinext uses a JSON file plus a PID liveness check
+ *   (`process.kill(pid, 0)`), which is good enough for the dev-server
+ *   "another server is running" use case. Race conditions on lock acquisition
+ *   are tolerated: at worst, two dev servers race and one fails to bind a port.
+ * - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'
+ *   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin
+ *   to cache self-hosted Google Fonts, so this re-uses the same project-local
+ *   state directory rather than polluting `node_modules`.
+ */
+/**
+ * Information about a running dev server, stored inside the lock file itself.
+ */
+type DevServerInfo = {
+  pid: number;
+  port: number;
+  hostname: string;
+  appUrl: string;
+  startedAt: number; /** Project directory the server is running in. Used to detect stale entries. */
+  cwd: string;
+};
+type DevLockfile = {
+  /** Update the lock file contents (e.g. once the port is known after listen). */update(info: DevServerInfo): void; /** Release the lock — deletes the file. Safe to call multiple times. */
+  release(): void; /** Absolute path to the lock file. */
+  path: string;
+};
+/**
+ * Returns the absolute path to the lock file for a given project root.
+ */
+declare function getLockfilePath(root: string): string;
+/**
+ * Reads and parses the lock file at the given path. Returns `undefined` if the
+ * file doesn't exist or can't be parsed.
+ */
+declare function readLockfile(lockfilePath: string): DevServerInfo | undefined;
+/**
+ * Returns true if a process with the given PID is running.
+ *
+ * Uses `process.kill(pid, 0)`, which sends a null signal — it doesn't actually
+ * kill the process, it just checks if it exists. Throws `ESRCH` if the process
+ * doesn't exist, or `EPERM` if it exists but we don't have permission to
+ * signal it (in which case it's still running, just owned by someone else).
+ */
+declare function isPidAlive(pid: number): boolean;
+type FormatErrorOptions = {
+  /** Existing server info from the lock file, if readable. */existing: DevServerInfo | undefined; /** Project directory the new (failing) process is trying to run in. */
+  cwd: string; /** Path to the lock file. */
+  lockfilePath: string;
+};
+/**
+ * Format the error message printed when another dev server is already running.
+ *
+ * Matches Next.js' error layout so AI agents and CLIs can parse the same
+ * `- PID: ` / `- Local: ` lines.
+ *
+ * The `existing: undefined` branch below is defensive — `tryAcquireLockfile`
+ * currently only returns `ok: false` with a defined `existing`, but the
+ * formatter is exported and unit-tested separately, so it handles both shapes.
+ */
+declare function formatAlreadyRunningError(opts: FormatErrorOptions): string;
+type AcquireOptions = {
+  /** Project root. Lock file goes in `<root>/.vinext/dev/lock.json`. */root: string; /** Initial server info to write. Port/URL may be updated later via `update()`. */
+  info: DevServerInfo;
+  /**
+   * If a lock file exists but its PID is dead, take over instead of failing.
+   * Defaults to `true`. Set to `false` for testing.
+   */
+  takeOverStale?: boolean; /** Register `process.on('exit', release)`. Defaults to `true`. */
+  unlockOnExit?: boolean;
+};
+type AcquireSuccess = {
+  ok: true;
+  lockfile: DevLockfile;
+};
+type AcquireFailure = {
+  ok: false; /** The server info from the existing lock file, if readable. */
+  existing: DevServerInfo | undefined; /** Absolute path to the lock file. */
+  lockfilePath: string;
+};
+type AcquireResult = AcquireSuccess | AcquireFailure;
+/**
+ * Try to acquire the dev lock file for the given project root.
+ *
+ * Returns `{ ok: true, lockfile }` on success — the caller should call
+ * `lockfile.release()` on shutdown (or rely on the exit listener registered
+ * via `unlockOnExit`).
+ *
+ * Returns `{ ok: false, existing, lockfilePath }` if another live dev server
+ * already holds the lock.
+ */
+declare function tryAcquireLockfile(opts: AcquireOptions): AcquireResult;
+//#endregion
+export { DevLockfile, DevServerInfo, formatAlreadyRunningError, getLockfilePath, isPidAlive, readLockfile, tryAcquireLockfile };
+//# sourceMappingURL=dev-lockfile.d.ts.map

package/dist/server/dev-lockfile.js

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/server/dev-lockfile.ts
+/**
+* Dev server lock file.
+*
+* Writes the running dev server's PID, port, and URL into a lock file at
+* `<root>/.vinext/dev/lock.json`. When a second `vinext dev` process starts in
+* the same project directory, it reads the lock file and either fails with an
+* actionable error or, if the previous process is dead, takes over the lock.
+*
+* This is especially useful for AI coding agents, which frequently attempt to
+* start `vinext dev` without knowing a server is already running.
+*
+* Ported behaviorally from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/build/lockfile.ts
+*
+* Differences vs Next.js:
+* - No native `flock()`. Next.js uses Rust SWC bindings for cross-platform
+*   advisory locking; vinext uses a JSON file plus a PID liveness check
+*   (`process.kill(pid, 0)`), which is good enough for the dev-server
+*   "another server is running" use case. Race conditions on lock acquisition
+*   are tolerated: at worst, two dev servers race and one fails to bind a port.
+* - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'
+*   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin
+*   to cache self-hosted Google Fonts, so this re-uses the same project-local
+*   state directory rather than polluting `node_modules`.
+*/
+const LOCK_DIR_RELATIVE = path.join(".vinext", "dev");
+const LOCK_FILE_NAME = "lock.json";
+/**
+* Returns the absolute path to the lock file for a given project root.
+*/
+function getLockfilePath(root) {
+	return path.join(root, LOCK_DIR_RELATIVE, LOCK_FILE_NAME);
+}
+/**
+* Reads and parses the lock file at the given path. Returns `undefined` if the
+* file doesn't exist or can't be parsed.
+*/
+function readLockfile(lockfilePath) {
+	let content;
+	try {
+		content = fs.readFileSync(lockfilePath, "utf-8");
+	} catch {
+		return;
+	}
+	try {
+		const parsed = JSON.parse(content);
+		if (typeof parsed.pid === "number" && typeof parsed.port === "number" && typeof parsed.hostname === "string" && typeof parsed.appUrl === "string" && typeof parsed.startedAt === "number" && typeof parsed.cwd === "string") return parsed;
+		return;
+	} catch {
+		return;
+	}
+}
+/**
+* Returns true if a process with the given PID is running.
+*
+* Uses `process.kill(pid, 0)`, which sends a null signal — it doesn't actually
+* kill the process, it just checks if it exists. Throws `ESRCH` if the process
+* doesn't exist, or `EPERM` if it exists but we don't have permission to
+* signal it (in which case it's still running, just owned by someone else).
+*/
+function isPidAlive(pid) {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+/**
+* Writes the lock file with the given content. Creates the parent directory
+* if it doesn't exist.
+*
+* Mode `0o600` because the lock file contains a PID that, in principle, lets
+* other users on the machine send signals to this user's dev server.
+* Restricting reads is defense-in-depth: the PID is also discoverable via
+* `ps` and the port via `netstat`/`ss`, so this isn't load-bearing.
+*/
+function writeLockfile(lockfilePath, info) {
+	fs.mkdirSync(path.dirname(lockfilePath), { recursive: true });
+	fs.writeFileSync(lockfilePath, JSON.stringify(info, null, 2), { mode: 384 });
+}
+/**
+* Format the error message printed when another dev server is already running.
+*
+* Matches Next.js' error layout so AI agents and CLIs can parse the same
+* `- PID: ` / `- Local: ` lines.
+*
+* The `existing: undefined` branch below is defensive — `tryAcquireLockfile`
+* currently only returns `ok: false` with a defined `existing`, but the
+* formatter is exported and unit-tested separately, so it handles both shapes.
+*/
+function formatAlreadyRunningError(opts) {
+	const { existing, cwd, lockfilePath } = opts;
+	if (!existing) return [
+		"Another vinext dev server appears to be running in this directory.",
+		"",
+		`Stale lock file: ${path.relative(cwd, lockfilePath)}`,
+		"Remove it manually if no server is running, then re-run `vinext dev`."
+	].join("\n");
+	const killCommand = process.platform === "win32" ? `taskkill /PID ${existing.pid} /F` : `kill ${existing.pid}`;
+	return [
+		"Another vinext dev server is already running.",
+		"",
+		`- Local:        ${existing.appUrl}`,
+		`- PID:          ${existing.pid}`,
+		`- Dir:          ${existing.cwd}`,
+		"",
+		`You can access the existing server at ${existing.appUrl},`,
+		`or run \`${killCommand}\` to stop it and start a new one.`
+	].join("\n");
+}
+/**
+* Try to acquire the dev lock file for the given project root.
+*
+* Returns `{ ok: true, lockfile }` on success — the caller should call
+* `lockfile.release()` on shutdown (or rely on the exit listener registered
+* via `unlockOnExit`).
+*
+* Returns `{ ok: false, existing, lockfilePath }` if another live dev server
+* already holds the lock.
+*/
+function tryAcquireLockfile(opts) {
+	const { root, info, takeOverStale = true, unlockOnExit = true } = opts;
+	const lockfilePath = getLockfilePath(root);
+	const existing = readLockfile(lockfilePath);
+	if (existing) {
+		if (isPidAlive(existing.pid)) return {
+			ok: false,
+			existing,
+			lockfilePath
+		};
+		if (!takeOverStale) return {
+			ok: false,
+			existing,
+			lockfilePath
+		};
+	}
+	writeLockfile(lockfilePath, info);
+	const ownerPid = info.pid;
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		try {
+			const current = readLockfile(lockfilePath);
+			if (current && current.pid === ownerPid) fs.unlinkSync(lockfilePath);
+		} catch {}
+	};
+	let exitListener;
+	if (unlockOnExit) {
+		exitListener = () => release();
+		process.on("exit", exitListener);
+	}
+	return {
+		ok: true,
+		lockfile: {
+			path: lockfilePath,
+			update(next) {
+				try {
+					writeLockfile(lockfilePath, next);
+				} catch {}
+			},
+			release() {
+				release();
+				if (exitListener) {
+					process.off("exit", exitListener);
+					exitListener = void 0;
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { formatAlreadyRunningError, getLockfilePath, isPidAlive, readLockfile, tryAcquireLockfile };
+
+//# sourceMappingURL=dev-lockfile.js.map

package/dist/server/dev-lockfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-lockfile.js","names":[],"sources":["../../src/server/dev-lockfile.ts"],"sourcesContent":["/**\n * Dev server lock file.\n *\n * Writes the running dev server's PID, port, and URL into a lock file at\n * `<root>/.vinext/dev/lock.json`. When a second `vinext dev` process starts in\n * the same project directory, it reads the lock file and either fails with an\n * actionable error or, if the previous process is dead, takes over the lock.\n *\n * This is especially useful for AI coding agents, which frequently attempt to\n * start `vinext dev` without knowing a server is already running.\n *\n * Ported behaviorally from Next.js:\n *   https://github.com/vercel/next.js/blob/canary/packages/next/src/build/lockfile.ts\n *\n * Differences vs Next.js:\n * - No native `flock()`. Next.js uses Rust SWC bindings for cross-platform\n *   advisory locking; vinext uses a JSON file plus a PID liveness check\n *   (`process.kill(pid, 0)`), which is good enough for the dev-server\n *   \"another server is running\" use case. Race conditions on lock acquisition\n *   are tolerated: at worst, two dev servers race and one fails to bind a port.\n * - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'\n *   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin\n *   to cache self-hosted Google Fonts, so this re-uses the same project-local\n *   state directory rather than polluting `node_modules`.\n */\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\n\nconst LOCK_DIR_RELATIVE = path.join(\".vinext\", \"dev\");\nconst LOCK_FILE_NAME = \"lock.json\";\n\n/**\n * Information about a running dev server, stored inside the lock file itself.\n */\nexport type DevServerInfo = {\n  pid: number;\n  port: number;\n  hostname: string;\n  appUrl: string;\n  startedAt: number;\n  /** Project directory the server is running in. Used to detect stale entries. */\n  cwd: string;\n};\n\nexport type DevLockfile = {\n  /** Update the lock file contents (e.g. once the port is known after listen). */\n  update(info: DevServerInfo): void;\n  /** Release the lock — deletes the file. Safe to call multiple times. */\n  release(): void;\n  /** Absolute path to the lock file. */\n  path: string;\n};\n\n/**\n * Returns the absolute path to the lock file for a given project root.\n */\nexport function getLockfilePath(root: string): string {\n  return path.join(root, LOCK_DIR_RELATIVE, LOCK_FILE_NAME);\n}\n\n/**\n * Reads and parses the lock file at the given path. Returns `undefined` if the\n * file doesn't exist or can't be parsed.\n */\nexport function readLockfile(lockfilePath: string): DevServerInfo | undefined {\n  let content: string;\n  try {\n    content = fs.readFileSync(lockfilePath, \"utf-8\");\n  } catch {\n    return undefined;\n  }\n  try {\n    const parsed = JSON.parse(content) as DevServerInfo;\n    if (\n      typeof parsed.pid === \"number\" &&\n      typeof parsed.port === \"number\" &&\n      typeof parsed.hostname === \"string\" &&\n      typeof parsed.appUrl === \"string\" &&\n      typeof parsed.startedAt === \"number\" &&\n      typeof parsed.cwd === \"string\"\n    ) {\n      return parsed;\n    }\n    return undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Returns true if a process with the given PID is running.\n *\n * Uses `process.kill(pid, 0)`, which sends a null signal — it doesn't actually\n * kill the process, it just checks if it exists. Throws `ESRCH` if the process\n * doesn't exist, or `EPERM` if it exists but we don't have permission to\n * signal it (in which case it's still running, just owned by someone else).\n */\nexport function isPidAlive(pid: number): boolean {\n  if (!Number.isInteger(pid) || pid <= 0) return false;\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (err) {\n    const code = (err as NodeJS.ErrnoException).code;\n    // EPERM means the process exists but we lack permission — still alive.\n    return code === \"EPERM\";\n  }\n}\n\n/**\n * Writes the lock file with the given content. Creates the parent directory\n * if it doesn't exist.\n *\n * Mode `0o600` because the lock file contains a PID that, in principle, lets\n * other users on the machine send signals to this user's dev server.\n * Restricting reads is defense-in-depth: the PID is also discoverable via\n * `ps` and the port via `netstat`/`ss`, so this isn't load-bearing.\n */\nfunction writeLockfile(lockfilePath: string, info: DevServerInfo): void {\n  fs.mkdirSync(path.dirname(lockfilePath), { recursive: true });\n  fs.writeFileSync(lockfilePath, JSON.stringify(info, null, 2), { mode: 0o600 });\n}\n\ntype FormatErrorOptions = {\n  /** Existing server info from the lock file, if readable. */\n  existing: DevServerInfo | undefined;\n  /** Project directory the new (failing) process is trying to run in. */\n  cwd: string;\n  /** Path to the lock file. */\n  lockfilePath: string;\n};\n\n/**\n * Format the error message printed when another dev server is already running.\n *\n * Matches Next.js' error layout so AI agents and CLIs can parse the same\n * `- PID: ` / `- Local: ` lines.\n *\n * The `existing: undefined` branch below is defensive — `tryAcquireLockfile`\n * currently only returns `ok: false` with a defined `existing`, but the\n * formatter is exported and unit-tested separately, so it handles both shapes.\n */\nexport function formatAlreadyRunningError(opts: FormatErrorOptions): string {\n  const { existing, cwd, lockfilePath } = opts;\n\n  if (!existing) {\n    // Defensive fallback. Not reachable from tryAcquireLockfile today.\n    return [\n      \"Another vinext dev server appears to be running in this directory.\",\n      \"\",\n      `Stale lock file: ${path.relative(cwd, lockfilePath)}`,\n      \"Remove it manually if no server is running, then re-run `vinext dev`.\",\n    ].join(\"\\n\");\n  }\n\n  const killCommand =\n    process.platform === \"win32\" ? `taskkill /PID ${existing.pid} /F` : `kill ${existing.pid}`;\n\n  return [\n    \"Another vinext dev server is already running.\",\n    \"\",\n    `- Local:        ${existing.appUrl}`,\n    `- PID:          ${existing.pid}`,\n    `- Dir:          ${existing.cwd}`,\n    \"\",\n    `You can access the existing server at ${existing.appUrl},`,\n    `or run \\`${killCommand}\\` to stop it and start a new one.`,\n  ].join(\"\\n\");\n}\n\ntype AcquireOptions = {\n  /** Project root. Lock file goes in `<root>/.vinext/dev/lock.json`. */\n  root: string;\n  /** Initial server info to write. Port/URL may be updated later via `update()`. */\n  info: DevServerInfo;\n  /**\n   * If a lock file exists but its PID is dead, take over instead of failing.\n   * Defaults to `true`. Set to `false` for testing.\n   */\n  takeOverStale?: boolean;\n  /** Register `process.on('exit', release)`. Defaults to `true`. */\n  unlockOnExit?: boolean;\n};\n\ntype AcquireSuccess = {\n  ok: true;\n  lockfile: DevLockfile;\n};\n\ntype AcquireFailure = {\n  ok: false;\n  /** The server info from the existing lock file, if readable. */\n  existing: DevServerInfo | undefined;\n  /** Absolute path to the lock file. */\n  lockfilePath: string;\n};\n\ntype AcquireResult = AcquireSuccess | AcquireFailure;\n\n/**\n * Try to acquire the dev lock file for the given project root.\n *\n * Returns `{ ok: true, lockfile }` on success — the caller should call\n * `lockfile.release()` on shutdown (or rely on the exit listener registered\n * via `unlockOnExit`).\n *\n * Returns `{ ok: false, existing, lockfilePath }` if another live dev server\n * already holds the lock.\n */\nexport function tryAcquireLockfile(opts: AcquireOptions): AcquireResult {\n  const { root, info, takeOverStale = true, unlockOnExit = true } = opts;\n  const lockfilePath = getLockfilePath(root);\n\n  const existing = readLockfile(lockfilePath);\n  if (existing) {\n    const alive = isPidAlive(existing.pid);\n    if (alive) {\n      return { ok: false, existing, lockfilePath };\n    }\n    if (!takeOverStale) {\n      return { ok: false, existing, lockfilePath };\n    }\n    // Existing entry is stale (dead PID). Fall through and overwrite.\n  }\n\n  // NB: there is a small TOCTOU window between readLockfile() above and\n  // writeLockfile() here. Two processes starting simultaneously can both\n  // pass the check and both write the lock file. This is intentionally\n  // tolerated — the loser will fail to bind its port, producing a clear\n  // error. A native flock() (the approach Next.js takes via Rust bindings)\n  // would close the window, but it's not worth the complexity for a\n  // dev-ergonomics feature.\n  writeLockfile(lockfilePath, info);\n\n  // Capture the owner PID once so release() always asks \"is the file still\n  // mine?\" against the same identity, regardless of what update() writes\n  // later. In practice the PID never changes between acquire and release,\n  // but this makes the intent explicit and decouples release from update.\n  const ownerPid = info.pid;\n\n  let released = false;\n  const release = () => {\n    if (released) return;\n    released = true;\n    try {\n      // Only delete if the file still points at us. If another process took\n      // over the lock (e.g. after a crash), don't delete their entry.\n      const current = readLockfile(lockfilePath);\n      if (current && current.pid === ownerPid) {\n        fs.unlinkSync(lockfilePath);\n      }\n    } catch {\n      // Best-effort cleanup.\n    }\n  };\n\n  // The \"exit\" event fires once Node.js is about to exit — either gracefully\n  // (event loop drained, explicit process.exit(), or after the default\n  // SIGINT/SIGTERM handlers terminate the process). It does NOT fire on\n  // uncaught exceptions or hard crashes (SIGKILL), which is fine: the next\n  // `vinext dev` will detect the dead PID and take over the stale lock.\n  //\n  // If a future caller installs a custom signal handler that swallows\n  // SIGINT/SIGTERM without exiting, the lock would leak — also fine, same\n  // recovery path applies.\n  let exitListener: NodeJS.ExitListener | undefined;\n  if (unlockOnExit) {\n    exitListener = () => release();\n    process.on(\"exit\", exitListener);\n  }\n\n  const lockfile: DevLockfile = {\n    path: lockfilePath,\n    update(next: DevServerInfo): void {\n      try {\n        writeLockfile(lockfilePath, next);\n      } catch {\n        // Best-effort; not fatal.\n      }\n    },\n    release(): void {\n      release();\n      if (exitListener) {\n        process.off(\"exit\", exitListener);\n        exitListener = undefined;\n      }\n    },\n  };\n\n  return { ok: true, lockfile };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,oBAAoB,KAAK,KAAK,WAAW,MAAM;AACrD,MAAM,iBAAiB;;;;AA2BvB,SAAgB,gBAAgB,MAAsB;CACpD,OAAO,KAAK,KAAK,MAAM,mBAAmB,eAAe;;;;;;AAO3D,SAAgB,aAAa,cAAiD;CAC5E,IAAI;CACJ,IAAI;EACF,UAAU,GAAG,aAAa,cAAc,QAAQ;SAC1C;EACN;;CAEF,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,QAAQ;EAClC,IACE,OAAO,OAAO,QAAQ,YACtB,OAAO,OAAO,SAAS,YACvB,OAAO,OAAO,aAAa,YAC3B,OAAO,OAAO,WAAW,YACzB,OAAO,OAAO,cAAc,YAC5B,OAAO,OAAO,QAAQ,UAEtB,OAAO;EAET;SACM;EACN;;;;;;;;;;;AAYJ,SAAgB,WAAW,KAAsB;CAC/C,IAAI,CAAC,OAAO,UAAU,IAAI,IAAI,OAAO,GAAG,OAAO;CAC/C,IAAI;EACF,QAAQ,KAAK,KAAK,EAAE;EACpB,OAAO;UACA,KAAK;EAGZ,OAFc,IAA8B,SAE5B;;;;;;;;;;;;AAapB,SAAS,cAAc,cAAsB,MAA2B;CACtE,GAAG,UAAU,KAAK,QAAQ,aAAa,EAAE,EAAE,WAAW,MAAM,CAAC;CAC7D,GAAG,cAAc,cAAc,KAAK,UAAU,MAAM,MAAM,EAAE,EAAE,EAAE,MAAM,KAAO,CAAC;;;;;;;;;;;;AAsBhF,SAAgB,0BAA0B,MAAkC;CAC1E,MAAM,EAAE,UAAU,KAAK,iBAAiB;CAExC,IAAI,CAAC,UAEH,OAAO;EACL;EACA;EACA,oBAAoB,KAAK,SAAS,KAAK,aAAa;EACpD;EACD,CAAC,KAAK,KAAK;CAGd,MAAM,cACJ,QAAQ,aAAa,UAAU,iBAAiB,SAAS,IAAI,OAAO,QAAQ,SAAS;CAEvF,OAAO;EACL;EACA;EACA,mBAAmB,SAAS;EAC5B,mBAAmB,SAAS;EAC5B,mBAAmB,SAAS;EAC5B;EACA,yCAAyC,SAAS,OAAO;EACzD,YAAY,YAAY;EACzB,CAAC,KAAK,KAAK;;;;;;;;;;;;AA0Cd,SAAgB,mBAAmB,MAAqC;CACtE,MAAM,EAAE,MAAM,MAAM,gBAAgB,MAAM,eAAe,SAAS;CAClE,MAAM,eAAe,gBAAgB,KAAK;CAE1C,MAAM,WAAW,aAAa,aAAa;CAC3C,IAAI,UAAU;EAEZ,IADc,WAAW,SAAS,IACzB,EACP,OAAO;GAAE,IAAI;GAAO;GAAU;GAAc;EAE9C,IAAI,CAAC,eACH,OAAO;GAAE,IAAI;GAAO;GAAU;GAAc;;CAYhD,cAAc,cAAc,KAAK;CAMjC,MAAM,WAAW,KAAK;CAEtB,IAAI,WAAW;CACf,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,IAAI;GAGF,MAAM,UAAU,aAAa,aAAa;GAC1C,IAAI,WAAW,QAAQ,QAAQ,UAC7B,GAAG,WAAW,aAAa;UAEvB;;CAcV,IAAI;CACJ,IAAI,cAAc;EAChB,qBAAqB,SAAS;EAC9B,QAAQ,GAAG,QAAQ,aAAa;;CAqBlC,OAAO;EAAE,IAAI;EAAM,UAAA;GAjBjB,MAAM;GACN,OAAO,MAA2B;IAChC,IAAI;KACF,cAAc,cAAc,KAAK;YAC3B;;GAIV,UAAgB;IACd,SAAS;IACT,IAAI,cAAc;KAChB,QAAQ,IAAI,QAAQ,aAAa;KACjC,eAAe,KAAA;;;GAKM;EAAE"}

package/dist/server/dev-server.d.ts

@@ -38,7 +38,15 @@ declare function parseCookieLocale(req: IncomingMessage, i18nConfig: NextI18nCon
  */
 declare function createSSRHandler(server: ViteDevServer, runner: ModuleImporter, routes: Route[], pagesDir: string, i18nConfig?: NextI18nConfig | null, fileMatcher?: ValidFileMatcher, basePath?: string, trailingSlash?: boolean): (req: IncomingMessage, res: ServerResponse, url: string, /** Status code override — propagated from middleware rewrite status. */
 
-statusCode?: number) => Promise<void>;
+statusCode?: number,
+/**
+ * True when the request originated as `/_next/data/<buildId>/<page>.json`.
+ * When true the handler emits a `{ pageProps }` JSON envelope instead of
+ * rendering the React tree to HTML — matching Next.js' behavior for
+ * client-side navigations in the Pages Router.
+ */
+
+isDataReq?: boolean) => Promise<void>;
 //#endregion
 export { createSSRHandler, detectLocaleFromHeaders, extractLocaleFromUrl, parseCookieLocale };
 //# sourceMappingURL=dev-server.d.ts.map

package/dist/server/dev-server.js

@@ -2,13 +2,14 @@ import { createRequestContext, runWithRequestContext } from "../shims/unified-re
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { matchRoute } from "../routing/pages-router.js";
-import { VINEXT_CACHE_HEADER } from "./headers.js";
+import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
+import { buildCacheStateHeaders } from "./cache-headers.js";
 import { _runWithCacheState } from "../shims/cache.js";
 import { buildPagesCacheValue, getRevalidateDuration, isrCacheKey, isrGet, isrSet, setRevalidateDuration, triggerBackgroundRegeneration } from "./isr-cache.js";
 import { runWithPrivateCache } from "../shims/cache-runtime.js";
 import { ensureFetchPatch, runWithFetchCache } from "../shims/fetch-cache.js";
-import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import "../shims/router-state.js";
 import { runWithHeadState } from "../shims/head-state.js";
 import { runWithServerInsertedHTMLState } from "../shims/navigation-state.js";
@@ -135,7 +136,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 	const matcher = fileMatcher ?? createValidFileMatcher();
 	const _alsRegistration = Promise.all([runner.import("vinext/head-state"), runner.import("vinext/router-state")]);
 	_alsRegistration.catch(() => {});
-	return async (req, res, url, statusCode) => {
+	return async (req, res, url, statusCode, isDataReq = false) => {
 		const _reqStart = now();
 		let _compileEnd;
 		let _renderEnd;
@@ -169,10 +170,16 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 		}
 		const match = matchRoute(localeStrippedUrl, routes);
 		if (!match) {
+			if (isDataReq) {
+				res.writeHead(404, { "Content-Type": "application/json" });
+				res.end("{}");
+				return;
+			}
 			await renderErrorPage(server, runner, req, res, url, pagesDir, 404, void 0, matcher);
 			return;
 		}
 		const { route, params } = match;
+		const userFacingParams = route.isDynamic ? params : null;
 		const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 		return runWithRequestContext(createRequestContext(), async () => {
 			ensureFetchPatch();
@@ -210,27 +217,53 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 				}
 				let pageProps = {};
 				let isrRevalidateSeconds = null;
+				let isFallbackRender = false;
 				if (typeof pageModule.getStaticPaths === "function" && route.isDynamic) {
 					const pathsResult = await pageModule.getStaticPaths({
 						locales: i18nConfig?.locales ?? [],
 						defaultLocale: currentDefaultLocale ?? ""
 					});
-					if ((pathsResult?.fallback ?? false) === false) {
-						if (!(pathsResult?.paths ?? []).some((p) => Object.entries(p.params).every(([key, val]) => {
+					const fallback = pathsResult?.fallback ?? false;
+					const paths = pathsResult?.paths ?? [];
+					const currentPathname = normalizeStaticPathname(url);
+					const isValidPath = paths.some((p) => {
+						if (typeof p === "string") return normalizeStaticPathname(p) === currentPathname;
+						const entryParams = p.params;
+						if (entryParams === void 0 || entryParams === null) return false;
+						return Object.entries(entryParams).every(([key, val]) => {
 							const actual = params[key];
 							if (Array.isArray(val)) return Array.isArray(actual) && val.join("/") === actual.join("/");
 							return String(val) === String(actual);
-						}))) {
-							await renderErrorPage(server, runner, req, res, url, pagesDir, 404, routerShim.wrapWithRouterContext, matcher);
+						});
+					});
+					if (fallback === false && !isValidPath) {
+						if (isDataReq) {
+							res.writeHead(404, { "Content-Type": "application/json" });
+							res.end("{}");
 							return;
 						}
+						await renderErrorPage(server, runner, req, res, url, pagesDir, 404, routerShim.wrapWithRouterContext, matcher);
+						return;
+					}
+					if (fallback === true && !isValidPath && !isDataReq) {
+						isFallbackRender = true;
+						if (typeof routerShim.setSSRContext === "function") routerShim.setSSRContext({
+							pathname: patternToNextFormat(route.pattern),
+							query,
+							asPath: url,
+							locale: locale ?? currentDefaultLocale,
+							locales: i18nConfig?.locales,
+							defaultLocale: currentDefaultLocale,
+							domainLocales,
+							isFallback: true
+						});
 					}
 				}
 				const gsspExtraHeaders = {};
-				if (typeof pageModule.getServerSideProps === "function") {
+				if (typeof pageModule.getServerSideProps === "function" && !isFallbackRender) {
 					const headersBeforeGSSP = new Set(Object.keys(res.getHeaders()));
 					const context = {
-						params,
+						params: userFacingParams,
 						req,
 						res,
 						query,
@@ -252,6 +285,11 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						return;
 					}
 					if (result && "notFound" in result && result.notFound) {
+						if (isDataReq) {
+							res.writeHead(404, { "Content-Type": "application/json" });
+							res.end("{}");
+							return;
+						}
 						await renderErrorPage(server, runner, req, res, url, pagesDir, 404, routerShim.wrapWithRouterContext);
 						return;
 					}
@@ -275,16 +313,16 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 					if (typeof fontLocalEarly.getSSRFontPreloads === "function") earlyPreloads.push(...fontLocalEarly.getSSRFontPreloads());
 					if (earlyPreloads.length > 0) earlyFontLinkHeader = earlyPreloads.map((p) => `<${p.href}>; rel=preload; as=font; type=${p.type}; crossorigin`).join(", ");
 				} catch {}
-				if (typeof pageModule.getStaticProps === "function") {
+				if (typeof pageModule.getStaticProps === "function" && !isFallbackRender) {
 					const cacheKey = isrCacheKey("pages", url.split("?")[0], process.env.__VINEXT_BUILD_ID);
 					const cached = await isrGet(cacheKey);
-					if (cached && !cached.isStale && cached.value.value?.kind === "PAGES" && !scriptNonce) {
+					if (cached && !cached.isStale && cached.value.value?.kind === "PAGES" && !scriptNonce && !isDataReq) {
 						const cachedHtml = cached.value.value.html;
 						const transformedHtml = await server.transformIndexHtml(url, cachedHtml);
 						const revalidateSecs = getRevalidateDuration(cacheKey) ?? 60;
 						const hitHeaders = {
 							"Content-Type": "text/html",
-							[VINEXT_CACHE_HEADER]: "HIT",
+							...buildCacheStateHeaders("HIT"),
 							"Cache-Control": `s-maxage=${revalidateSecs}, stale-while-revalidate`
 						};
 						if (earlyFontLinkHeader) hitHeaders["Link"] = earlyFontLinkHeader;
@@ -292,14 +330,14 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						res.end(transformedHtml);
 						return;
 					}
-					if (cached && cached.isStale && cached.value.value?.kind === "PAGES" && !scriptNonce) {
+					if (cached && cached.isStale && cached.value.value?.kind === "PAGES" && !scriptNonce && !isDataReq) {
 						const cachedHtml = cached.value.value.html;
 						const transformedHtml = await server.transformIndexHtml(url, cachedHtml);
 						triggerBackgroundRegeneration(cacheKey, async () => {
 							return runWithRequestContext(createRequestContext({ executionContext: null }), async () => {
 								ensureFetchPatch();
 								const freshResult = await pageModule.getStaticProps({
-									params,
+									params: userFacingParams,
 									locale: locale ?? currentDefaultLocale,
 									locales: i18nConfig?.locales,
 									defaultLocale: currentDefaultLocale
@@ -369,7 +407,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						const revalidateSecs = getRevalidateDuration(cacheKey) ?? 60;
 						const staleHeaders = {
 							"Content-Type": "text/html",
-							[VINEXT_CACHE_HEADER]: "STALE",
+							...buildCacheStateHeaders("STALE"),
 							"Cache-Control": `s-maxage=${revalidateSecs}, stale-while-revalidate`
 						};
 						if (earlyFontLinkHeader) staleHeaders["Link"] = earlyFontLinkHeader;
@@ -378,7 +416,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						return;
 					}
 					const context = {
-						params,
+						params: userFacingParams,
 						locale: locale ?? currentDefaultLocale,
 						locales: i18nConfig?.locales,
 						defaultLocale: currentDefaultLocale
@@ -395,11 +433,24 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						return;
 					}
 					if (result && "notFound" in result && result.notFound) {
+						if (isDataReq) {
+							res.writeHead(404, { "Content-Type": "application/json" });
+							res.end("{}");
+							return;
+						}
 						await renderErrorPage(server, runner, req, res, url, pagesDir, 404, routerShim.wrapWithRouterContext);
 						return;
 					}
 					if (typeof result?.revalidate === "number" && result.revalidate > 0) isrRevalidateSeconds = result.revalidate;
 				}
+				if (isDataReq) {
+					const dataHeaders = { "Content-Type": "application/json" };
+					if (gsspExtraHeaders) for (const [k, v] of Object.entries(gsspExtraHeaders)) dataHeaders[k] = v;
+					res.writeHead(statusCode ?? 200, dataHeaders);
+					res.end(JSON.stringify({ pageProps }));
+					_renderEnd = now();
+					return;
+				}
 				let AppComponent = null;
 				const appPath = path.join(pagesDir, "_app");
 				if (findFileWithExtensions(appPath, matcher)) try {
@@ -453,6 +504,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
+import { installPagesRouterRuntime } from "vinext/pages-router-runtime";
 import { wrapWithRouterContext } from "next/router";
 
 const nextData = window.__NEXT_DATA__;
@@ -473,7 +525,12 @@ async function hydrate() {
   element = wrapWithRouterContext(element);
   const root = hydrateRoot(document.getElementById("__next"), element);
   window.__VINEXT_ROOT__ = root;
-  window.__VINEXT_HYDRATED_AT = performance.now();
+  installPagesRouterRuntime();
+  const hydratedAt = performance.now();
+  window.__VINEXT_HYDRATED_AT = hydratedAt;
+  window.__NEXT_HYDRATED = true;
+  window.__NEXT_HYDRATED_AT = hydratedAt;
+  window.__NEXT_HYDRATED_CB?.();
 }
 hydrate();
 <\/script>`;
@@ -482,7 +539,7 @@ hydrate();
 					page: patternToNextFormat(route.pattern),
 					query: params,
 					buildId: process.env.__VINEXT_BUILD_ID,
-					isFallback: false,
+					isFallback: isFallbackRender,
 					locale: locale ?? currentDefaultLocale,
 					locales: i18nConfig?.locales,
 					defaultLocale: currentDefaultLocale,
@@ -502,7 +559,7 @@ hydrate();
 				if (isrRevalidateSeconds) if (scriptNonce) extraHeaders["Cache-Control"] = "no-store, must-revalidate";
 				else {
 					extraHeaders["Cache-Control"] = `s-maxage=${isrRevalidateSeconds}, stale-while-revalidate`;
-					extraHeaders[VINEXT_CACHE_HEADER] = "MISS";
+					Object.assign(extraHeaders, buildCacheStateHeaders("MISS"));
 				}
 				if (allFontPreloads.length > 0) extraHeaders["Link"] = allFontPreloads.map((p) => `<${p.href}>; rel=preload; as=font; type=${p.type}; crossorigin`).join(", ");
 				await streamPageToResponse(res, withScriptNonce(element, scriptNonce), {