@qzsy/vinext 0.1.7

package/dist/utils/lazy-chunks.d.ts

@@ -0,0 +1,59 @@
+//#region src/utils/lazy-chunks.d.ts
+/**
+ * Build-manifest chunk metadata used to compute lazy chunks.
+ */
+type BuildManifestChunk = {
+  file: string;
+  isEntry?: boolean;
+  isDynamicEntry?: boolean;
+  imports?: string[];
+  dynamicImports?: string[];
+  css?: string[];
+  assets?: string[];
+};
+/**
+ * Compute the set of chunk filenames that are ONLY reachable through dynamic
+ * imports (i.e. behind React.lazy(), next/dynamic, or manual import()).
+ *
+ * These chunks should NOT be modulepreloaded in the HTML — they will be
+ * fetched on demand when the dynamic import executes.
+ *
+ * Algorithm: Starting from all entry chunks in the build manifest, walk the
+ * static `imports` tree (breadth-first). Any chunk file NOT reached by this
+ * walk is only reachable through `dynamicImports` and is therefore "lazy".
+ *
+ * @param buildManifest - Vite's build manifest (manifest.json), which is a
+ *   Record<string, ManifestChunk> where each chunk has `file`, `imports`,
+ *   `dynamicImports`, `isEntry`, and `isDynamicEntry` fields.
+ * @returns Array of chunk filenames (e.g. "_next/static/mermaid-NOHMQCX5.js") that
+ *   should be excluded from modulepreload hints.
+ */
+declare function computeLazyChunks(buildManifest: Record<string, BuildManifestChunk>): string[];
+/**
+ * Compute the production preload files for each module referenced by a
+ * `next/dynamic()` boundary.
+ *
+ * Next.js records module IDs during compilation, then resolves those IDs
+ * against its react-loadable manifest at render time. Vinext's equivalent
+ * source of truth is Vite's build manifest: each chunk lists the modules it
+ * reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+ * files required to evaluate it.
+ *
+ * Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+ * can include chunks that the page entry ALSO loads eagerly (a shared vendor
+ * chunk imported by both). Those files are intentionally NOT subtracted here, so
+ * a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+ * for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+ * the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+ * and React's stylesheet resource model dedupes by href + precedence — and it
+ * mirrors Next.js listing a module's full file set in its react-loadable
+ * manifest. Subtracting the eager set would couple this to the entry's import
+ * closure for no correctness gain.
+ *
+ * @returns A map keyed by root-relative module ID, with JS/CSS files that
+ * should be preloaded when that dynamic boundary is rendered.
+ */
+declare function computeDynamicImportPreloads(buildManifest: Record<string, BuildManifestChunk>): Record<string, string[]>;
+declare function dynamicImportPreloadsWithBase(preloads: Record<string, string[]>, applyBase: (file: string) => string): Record<string, string[]>;
+//#endregion
+export { BuildManifestChunk, computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/lazy-chunks.js

@@ -0,0 +1,112 @@
+//#region src/utils/lazy-chunks.ts
+/**
+* Compute the set of chunk filenames that are ONLY reachable through dynamic
+* imports (i.e. behind React.lazy(), next/dynamic, or manual import()).
+*
+* These chunks should NOT be modulepreloaded in the HTML — they will be
+* fetched on demand when the dynamic import executes.
+*
+* Algorithm: Starting from all entry chunks in the build manifest, walk the
+* static `imports` tree (breadth-first). Any chunk file NOT reached by this
+* walk is only reachable through `dynamicImports` and is therefore "lazy".
+*
+* @param buildManifest - Vite's build manifest (manifest.json), which is a
+*   Record<string, ManifestChunk> where each chunk has `file`, `imports`,
+*   `dynamicImports`, `isEntry`, and `isDynamicEntry` fields.
+* @returns Array of chunk filenames (e.g. "_next/static/mermaid-NOHMQCX5.js") that
+*   should be excluded from modulepreload hints.
+*/
+function computeLazyChunks(buildManifest) {
+	const eagerFiles = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [];
+	for (const key of Object.keys(buildManifest)) if (buildManifest[key].isEntry) queue.push(key);
+	while (queue.length > 0) {
+		const key = queue.shift();
+		if (!key || visited.has(key)) continue;
+		visited.add(key);
+		const chunk = buildManifest[key];
+		if (!chunk) continue;
+		eagerFiles.add(chunk.file);
+		if (chunk.css) for (const cssFile of chunk.css) eagerFiles.add(cssFile);
+		if (chunk.imports) {
+			for (const imp of chunk.imports) if (!visited.has(imp)) queue.push(imp);
+		}
+	}
+	const lazyChunks = [];
+	const allFiles = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(buildManifest)) {
+		const chunk = buildManifest[key];
+		if (chunk.file && !allFiles.has(chunk.file)) {
+			allFiles.add(chunk.file);
+			if (!eagerFiles.has(chunk.file) && chunk.file.endsWith(".js")) lazyChunks.push(chunk.file);
+		}
+	}
+	return lazyChunks;
+}
+function normalizeManifestKey(key) {
+	return key.split("?")[0].replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function addFile(files, seen, file) {
+	if (!file || seen.has(file)) return;
+	seen.add(file);
+	files.push(file);
+}
+function collectStaticChunkFiles(buildManifest, key, files, seenFiles, visitedChunks) {
+	if (visitedChunks.has(key)) return;
+	visitedChunks.add(key);
+	const chunk = buildManifest[key];
+	if (!chunk) return;
+	if (chunk.file.endsWith(".js")) addFile(files, seenFiles, chunk.file);
+	for (const cssFile of chunk.css ?? []) addFile(files, seenFiles, cssFile);
+	for (const importedKey of chunk.imports ?? []) collectStaticChunkFiles(buildManifest, importedKey, files, seenFiles, visitedChunks);
+}
+/**
+* Compute the production preload files for each module referenced by a
+* `next/dynamic()` boundary.
+*
+* Next.js records module IDs during compilation, then resolves those IDs
+* against its react-loadable manifest at render time. Vinext's equivalent
+* source of truth is Vite's build manifest: each chunk lists the modules it
+* reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+* files required to evaluate it.
+*
+* Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+* can include chunks that the page entry ALSO loads eagerly (a shared vendor
+* chunk imported by both). Those files are intentionally NOT subtracted here, so
+* a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+* for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+* the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+* and React's stylesheet resource model dedupes by href + precedence — and it
+* mirrors Next.js listing a module's full file set in its react-loadable
+* manifest. Subtracting the eager set would couple this to the entry's import
+* closure for no correctness gain.
+*
+* @returns A map keyed by root-relative module ID, with JS/CSS files that
+* should be preloaded when that dynamic boundary is rendered.
+*/
+function computeDynamicImportPreloads(buildManifest) {
+	const preloads = {};
+	for (const chunk of Object.values(buildManifest)) for (const dynamicKey of chunk.dynamicImports ?? []) {
+		const files = [];
+		collectStaticChunkFiles(buildManifest, dynamicKey, files, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+		if (files.length === 0) continue;
+		const normalizedKey = normalizeManifestKey(dynamicKey);
+		const existing = preloads[normalizedKey] ?? [];
+		const merged = new Set(existing);
+		for (const file of files) {
+			if (merged.has(file)) continue;
+			merged.add(file);
+			existing.push(file);
+		}
+		preloads[normalizedKey] = existing;
+	}
+	return preloads;
+}
+function dynamicImportPreloadsWithBase(preloads, applyBase) {
+	const withBase = {};
+	for (const [key, files] of Object.entries(preloads)) withBase[key] = files.map(applyBase);
+	return withBase;
+}
+//#endregion
+export { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/manifest-paths.d.ts

@@ -0,0 +1,30 @@
+//#region src/utils/manifest-paths.d.ts
+declare function manifestFileWithBase(file: string, base: string): string;
+declare function manifestFileWithAssetPrefix(file: string, base: string, assetPrefix: string): string;
+/**
+ * Resolve the URL a client asset is actually SERVED from, starting from a
+ * base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+ * `"docs/cdn/_next/static/x.js"`.
+ *
+ * Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+ * not stack). So when an `assetPrefix` is configured we strip the basePath
+ * segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+ * preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+ * / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+ * path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+ * which 404s. When no `assetPrefix` is set, the base-anchored value is already
+ * the served URL and is returned unchanged (just root-anchored).
+ *
+ * Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+ * root-relative URL beginning with `/`.
+ */
+declare function assetServingUrlFromBaseAnchored(value: string, basePath: string, assetPrefix: string): string;
+/**
+ * Strip a `base` prefix that Vite applied twice: it bakes `base` into the
+ * on-disk chunk fileName and then prepends it again in `ssr-manifest.json`,
+ * yielding `docs/docs/_next/static/...` which 404s. Only an exact
+ * `<base>/<base>/` prefix is collapsed; a single prefix is left untouched.
+ */
+declare function collapseDuplicateBase(file: string, base: string): string;
+//#endregion
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/manifest-paths.js

@@ -0,0 +1,66 @@
+import { ASSET_PREFIX_URL_DIR, isAbsoluteAssetPrefix, resolveAssetUrlPrefix, resolveAssetsDir } from "./asset-prefix.js";
+//#region src/utils/manifest-paths.ts
+function normalizeManifestFile(file) {
+	return file.startsWith("/") ? file.slice(1) : file;
+}
+function manifestFileWithBase(file, base) {
+	const normalizedFile = normalizeManifestFile(file);
+	if (!base || base === "/") return normalizedFile;
+	const normalizedBase = normalizeManifestFile(base).replace(/\/+$/, "");
+	if (!normalizedBase) return normalizedFile;
+	if (normalizedFile.startsWith(normalizedBase + "/")) return normalizedFile;
+	return normalizedBase + "/" + normalizedFile;
+}
+function manifestFileWithAssetPrefix(file, base, assetPrefix) {
+	if (!assetPrefix) return manifestFileWithBase(file, base);
+	const normalizedFile = normalizeManifestFile(file);
+	const onDiskDirPrefix = normalizeManifestFile(resolveAssetsDir(assetPrefix)) + "/";
+	const staticDirPrefix = ASSET_PREFIX_URL_DIR + "/";
+	const stripped = normalizedFile.startsWith(onDiskDirPrefix) ? normalizedFile.slice(onDiskDirPrefix.length) : normalizedFile.startsWith(staticDirPrefix) ? normalizedFile.slice(staticDirPrefix.length) : normalizedFile;
+	const urlPrefix = resolveAssetUrlPrefix(assetPrefix);
+	return (isAbsoluteAssetPrefix(assetPrefix) ? urlPrefix : normalizeManifestFile(urlPrefix)) + stripped;
+}
+function stripBasePathSegment(file, basePath) {
+	const normalizedBase = normalizeManifestFile(basePath).replace(/\/+$/, "");
+	if (!normalizedBase) return file;
+	return file.startsWith(normalizedBase + "/") ? file.slice(normalizedBase.length + 1) : file;
+}
+/**
+* Resolve the URL a client asset is actually SERVED from, starting from a
+* base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+* `"docs/cdn/_next/static/x.js"`.
+*
+* Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+* not stack). So when an `assetPrefix` is configured we strip the basePath
+* segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+* preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+* / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+* path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+* which 404s. When no `assetPrefix` is set, the base-anchored value is already
+* the served URL and is returned unchanged (just root-anchored).
+*
+* Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+* root-relative URL beginning with `/`.
+*/
+function assetServingUrlFromBaseAnchored(value, basePath, assetPrefix) {
+	const normalized = normalizeManifestFile(value);
+	if (!assetPrefix) return "/" + normalized;
+	const anchored = manifestFileWithAssetPrefix(stripBasePathSegment(normalized, basePath), "/", assetPrefix);
+	return isAbsoluteAssetPrefix(assetPrefix) ? anchored : "/" + anchored;
+}
+/**
+* Strip a `base` prefix that Vite applied twice: it bakes `base` into the
+* on-disk chunk fileName and then prepends it again in `ssr-manifest.json`,
+* yielding `docs/docs/_next/static/...` which 404s. Only an exact
+* `<base>/<base>/` prefix is collapsed; a single prefix is left untouched.
+*/
+function collapseDuplicateBase(file, base) {
+	const normalizedFile = normalizeManifestFile(file);
+	if (!base || base === "/") return normalizedFile;
+	const normalizedBase = normalizeManifestFile(base).replace(/\/+$/, "");
+	if (!normalizedBase) return normalizedFile;
+	const doubledPrefix = `${normalizedBase}/${normalizedBase}/`;
+	return normalizedFile.startsWith(doubledPrefix) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile;
+}
+//#endregion
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/mdx-scan.d.ts

@@ -0,0 +1,9 @@
+//#region src/utils/mdx-scan.d.ts
+/** Module-level cache for hasMdxFiles — avoids re-scanning per Vite environment. */
+declare const mdxScanCache: Map<string, boolean>;
+/**
+ * Check if the project has .mdx files in app/ or pages/ directories.
+ */
+declare function hasMdxFiles(root: string, appDir: string | null, pagesDir: string | null): boolean;
+//#endregion
+export { hasMdxFiles, mdxScanCache };

package/dist/utils/mdx-scan.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/mdx-scan.ts
+/** Module-level cache for hasMdxFiles — avoids re-scanning per Vite environment. */
+const mdxScanCache = /* @__PURE__ */ new Map();
+/**
+* Check if the project has .mdx files in app/ or pages/ directories.
+*/
+function hasMdxFiles(root, appDir, pagesDir) {
+	const cacheKey = `${root}\0${appDir ?? ""}\0${pagesDir ?? ""}`;
+	if (mdxScanCache.has(cacheKey)) return mdxScanCache.get(cacheKey);
+	const dirs = [appDir, pagesDir].filter(Boolean);
+	for (const dir of dirs) if (fs.existsSync(dir) && scanDirForMdx(dir)) {
+		mdxScanCache.set(cacheKey, true);
+		return true;
+	}
+	mdxScanCache.set(cacheKey, false);
+	return false;
+}
+function scanDirForMdx(dir) {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (scanDirForMdx(full)) return true;
+			} else if (entry.isFile() && entry.name.toLowerCase().endsWith(".mdx")) return true;
+		}
+	} catch {}
+	return false;
+}
+//#endregion
+export { hasMdxFiles, mdxScanCache };

package/dist/utils/navigation-signal.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/navigation-signal.d.ts
+declare function isNavigationSignalError(error: unknown): boolean;
+//#endregion
+export { isNavigationSignalError };

package/dist/utils/navigation-signal.js

@@ -0,0 +1,12 @@
+//#region src/utils/navigation-signal.ts
+function getErrorDigest(error) {
+	if (!error || typeof error !== "object" || !("digest" in error)) return null;
+	return String(error.digest);
+}
+function isNavigationSignalError(error) {
+	const digest = getErrorDigest(error);
+	if (digest === null) return false;
+	return digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;") || digest.startsWith("NEXT_REDIRECT;");
+}
+//#endregion
+export { isNavigationSignalError };

package/dist/utils/number.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/number.d.ts
+declare function isNonNegativeSafeInteger(value: unknown): value is number;
+//#endregion
+export { isNonNegativeSafeInteger };

package/dist/utils/number.js

@@ -0,0 +1,6 @@
+//#region src/utils/number.ts
+function isNonNegativeSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+//#endregion
+export { isNonNegativeSafeInteger };

package/dist/utils/parse-cookie.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/parse-cookie.d.ts
+type ParsedCookies = Record<string, string>;
+/**
+ * Parse a Cookie header using the semantics of Next.js's compiled `cookie`
+ * package.
+ */
+declare function parseCookieHeader(cookieHeader: string | null | undefined): ParsedCookies;
+/**
+ * Parse a Cookie header using Next.js/@edge-runtime RequestCookies semantics.
+ */
+declare function parseEdgeRequestCookieHeader(cookieHeader: string): Map<string, string>;
+//#endregion
+export { ParsedCookies, parseCookieHeader, parseEdgeRequestCookieHeader };

package/dist/utils/parse-cookie.js

@@ -0,0 +1,52 @@
+//#region src/utils/parse-cookie.ts
+function decodeCookieValue(value) {
+	try {
+		return {
+			ok: true,
+			value: decodeURIComponent(value)
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+function forEachCookieHeaderPart(cookieHeader, visit) {
+	for (const part of cookieHeader.split(/; */)) {
+		if (!part) continue;
+		visit(part, part.indexOf("="));
+	}
+}
+/**
+* Parse a Cookie header using the semantics of Next.js's compiled `cookie`
+* package.
+*/
+function parseCookieHeader(cookieHeader) {
+	const cookies = {};
+	if (!cookieHeader) return cookies;
+	forEachCookieHeaderPart(cookieHeader, (part, separator) => {
+		if (separator < 0) return;
+		const key = part.slice(0, separator).trim();
+		let value = part.slice(separator + 1).trim();
+		if (cookies[key] !== void 0) return;
+		if (value.startsWith("\"")) value = value.slice(1, -1);
+		const decoded = decodeCookieValue(value);
+		cookies[key] = decoded.ok ? decoded.value : value;
+	});
+	return cookies;
+}
+/**
+* Parse a Cookie header using Next.js/@edge-runtime RequestCookies semantics.
+*/
+function parseEdgeRequestCookieHeader(cookieHeader) {
+	const cookies = /* @__PURE__ */ new Map();
+	forEachCookieHeaderPart(cookieHeader, (part, separator) => {
+		if (separator === -1) {
+			cookies.set(part, "true");
+			return;
+		}
+		const decoded = decodeCookieValue(part.slice(separator + 1));
+		if (decoded.ok) cookies.set(part.slice(0, separator), decoded.value);
+	});
+	return cookies;
+}
+//#endregion
+export { parseCookieHeader, parseEdgeRequestCookieHeader };

package/dist/utils/path.d.ts

@@ -0,0 +1,22 @@
+//#region src/utils/path.d.ts
+/**
+ * Convert Windows-style backslash path separators to forward slashes.
+ *
+ * Generated entry modules embed absolute filesystem paths inside `import`
+ * statements. On Windows the OS-native paths use `\` which is invalid in JS
+ * module specifiers, so every entry generator normalizes paths through this
+ * helper before stringifying them into the emitted code.
+ *
+ * No-op on POSIX — skips the regex scan entirely since backslashes never
+ * appear in filesystem paths on Linux/macOS.
+ */
+declare function normalizePathSeparators(p: string): string;
+declare function stripViteModuleQuery(id: string): string;
+/** Strip a trailing `.js` extension from a module specifier so
+ *  `resolveShimModulePath` looks for the correct base name (e.g. `headers.js`
+ *  → `headers`). Public and internal shim imports may carry extensionful
+ *  subpaths; normalising before resolution prevents looking for non-existent
+ *  files like `headers.js.ts`. */
+declare function stripJsExtension(name: string): string;
+//#endregion
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/dist/utils/path.js

@@ -0,0 +1,30 @@
+//#region src/utils/path.ts
+const isWindows = process.platform === "win32";
+/**
+* Convert Windows-style backslash path separators to forward slashes.
+*
+* Generated entry modules embed absolute filesystem paths inside `import`
+* statements. On Windows the OS-native paths use `\` which is invalid in JS
+* module specifiers, so every entry generator normalizes paths through this
+* helper before stringifying them into the emitted code.
+*
+* No-op on POSIX — skips the regex scan entirely since backslashes never
+* appear in filesystem paths on Linux/macOS.
+*/
+function normalizePathSeparators(p) {
+	return isWindows ? p.replace(/\\/g, "/") : p;
+}
+function stripViteModuleQuery(id) {
+	const queryIndex = id.search(/[?#]/);
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+/** Strip a trailing `.js` extension from a module specifier so
+*  `resolveShimModulePath` looks for the correct base name (e.g. `headers.js`
+*  → `headers`). Public and internal shim imports may carry extensionful
+*  subpaths; normalising before resolution prevents looking for non-existent
+*  files like `headers.js.ts`. */
+function stripJsExtension(name) {
+	return name.endsWith(".js") ? name.slice(0, -3) : name;
+}
+//#endregion
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/dist/utils/prerender-output-paths.d.ts

@@ -0,0 +1,14 @@
+//#region src/utils/prerender-output-paths.d.ts
+/**
+ * Determine the HTML output file path for a prerendered URL.
+ * Respects trailingSlash config.
+ */
+declare function getOutputPath(urlPath: string, trailingSlash: boolean): string;
+/**
+ * Determine the RSC output file path for a prerendered URL.
+ * "/blog/hello-world" -> "blog/hello-world.rsc"
+ * "/"                 -> "index.rsc"
+ */
+declare function getRscOutputPath(urlPath: string): string;
+//#endregion
+export { getOutputPath, getRscOutputPath };

package/dist/utils/prerender-output-paths.js

@@ -0,0 +1,22 @@
+//#region src/utils/prerender-output-paths.ts
+/**
+* Determine the HTML output file path for a prerendered URL.
+* Respects trailingSlash config.
+*/
+function getOutputPath(urlPath, trailingSlash) {
+	if (urlPath === "/") return "index.html";
+	const clean = urlPath.replace(/^\//, "");
+	if (trailingSlash) return `${clean}/index.html`;
+	return `${clean}.html`;
+}
+/**
+* Determine the RSC output file path for a prerendered URL.
+* "/blog/hello-world" -> "blog/hello-world.rsc"
+* "/"                 -> "index.rsc"
+*/
+function getRscOutputPath(urlPath) {
+	if (urlPath === "/") return "index.rsc";
+	return urlPath.replace(/^\//, "") + ".rsc";
+}
+//#endregion
+export { getOutputPath, getRscOutputPath };

package/dist/utils/project.d.ts

@@ -0,0 +1,76 @@
+//#region src/utils/project.d.ts
+/**
+ * Shared project utilities — used by both `vinext init` and `vinext deploy`.
+ *
+ * These functions detect and modify project configuration without touching
+ * any Next.js source files, config files, or tsconfig.json.
+ */
+/**
+ * Ensure package.json has "type": "module".
+ * Returns true if it was added (i.e. it wasn't already there).
+ */
+declare function ensureESModule(root: string): boolean;
+/**
+ * Rename CJS config files (that use `module.exports`) to .cjs
+ * to avoid breakage when "type": "module" is added.
+ * Returns array of [oldName, newName] pairs that were renamed.
+ */
+declare function renameCJSConfigs(root: string): Array<[string, string]>;
+/**
+ * Ensure the project is configured for ESM before Vite loads vite.config.ts.
+ *
+ * This mirrors what `vinext init` does, but is applied lazily at dev/build
+ * time for projects that were set up before `vinext init` added the step.
+ *
+ * Side effects: may rename `.js` CJS config files to `.cjs` and add
+ * `"type": "module"` to package.json.
+ *
+ * @returns Object describing what was changed, or null if nothing was done.
+ */
+declare function ensureViteConfigCompatibility(root: string): {
+  renamed: Array<[string, string]>;
+  addedTypeModule: boolean;
+} | null;
+type PackageManagerName = "pnpm" | "yarn" | "bun" | "npm";
+/**
+ * Detect which package manager name is used.
+ * Priority:
+ * 1) lock files (walks up parent directories for monorepo support)
+ * 2) package.json#packageManager
+ * 3) invoking CLI user agent (npm_config_user_agent)
+ * 4) npm fallback
+ */
+declare function detectPackageManagerName(root: string, env?: Record<string, string | undefined>): PackageManagerName;
+/**
+ * Detect which package manager install command to use.
+ * Returns the dev-install command string (e.g. "pnpm add -D").
+ */
+declare function detectPackageManager(root: string): string;
+/**
+ * Walk from `start` up to the filesystem root looking for a path inside
+ * node_modules. Returns the first absolute path found, or null.
+ *
+ * Handles monorepos where packages are hoisted to the workspace root's
+ * node_modules rather than installed in each app's own node_modules.
+ *
+ * @param start   - Directory to begin the search (usually the project root)
+ * @param subPath - Path relative to a node_modules dir, e.g. ".bin/wrangler"
+ *                  or "@cloudflare/vite-plugin"
+ */
+declare function findInNodeModules(start: string, subPath: string): string | null;
+/**
+ * Check if a vite.config file exists in the project root.
+ */
+declare function hasViteConfig(root: string): boolean;
+/**
+ * Return the first candidate directory (resolved against `root`) that exists,
+ * or null. Used to locate conventional `app`/`pages` directories that may live
+ * at the root or under `src/`.
+ */
+declare function findDir(root: string, ...candidates: string[]): string | null;
+/**
+ * Check if the project uses App Router (has an app/ directory).
+ */
+declare function hasAppDir(root: string): boolean;
+//#endregion
+export { detectPackageManager, detectPackageManagerName, ensureESModule, ensureViteConfigCompatibility, findDir, findInNodeModules, hasAppDir, hasViteConfig, renameCJSConfigs };