vinext 0.0.54 → 0.1.0

package/README.md

@@ -271,15 +271,6 @@ vinext deploy --experimental-tpr --tpr-window 48    # Use 48h of analytics
 
 Requires a custom domain (zone analytics are unavailable on `*.workers.dev`) and `CLOUDFLARE_API_TOKEN` with Zone.Analytics read permission.
 
-For production caching (ISR), use the built-in Cloudflare KV cache handler:
-
-```ts
-import { KVCacheHandler } from "vinext/cloudflare";
-import { setCacheHandler } from "next/cache";
-
-setCacheHandler(new KVCacheHandler(env.MY_KV_NAMESPACE));
-```
-
 #### Custom Vite configuration
 
 If you need to customize the Vite config, create a `vite.config.ts`. vinext will merge its config with yours. This is required for Cloudflare Workers deployment with the App Router (RSC needs explicit plugin configuration):
@@ -533,14 +524,61 @@ Override behavior:
 
 ### Caching
 
-The cache is pluggable. The default `MemoryCacheHandler` works out of the box. Swap in your own backend for production:
+The cache is pluggable. The default `MemoryCacheHandler` works out of the box. Swap in your own backend for production.
+
+#### Configuring cache adapters from `vite.config`
+
+Instead of wiring up cache handlers imperatively from a worker entry, you can declare them in the `vinext()` plugin config. The `@vinext/cloudflare` package ships two Cloudflare adapters for this:
+
+- **`kvDataAdapter()`** (`@vinext/cloudflare/cache/kv-data-adapter`) — backs the `"use cache"` data cache with a Workers KV namespace.
+- **`cdnAdapter()`** (`@vinext/cloudflare/cache/cdn-adapter`) — backs full-route CDN caching with the Workers Cache API.
 
 ```ts
-import { setCacheHandler } from "next/cache";
-setCacheHandler(new MyCacheHandler()); // Redis, DynamoDB, etc.
+import { defineConfig } from "vite";
+import vinext from "vinext";
+import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
+import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
+
+export default defineConfig({
+  plugins: [
+    vinext({
+      cache: {
+        cdn: cdnAdapter(),
+        data: kvDataAdapter(),
+      },
+    }),
+  ],
+});
+```
+
+The KV data adapter reads `env[binding]` at runtime, so add the matching KV namespace to your `wrangler.jsonc`:
+
+```jsonc
+{
+  "kv_namespaces": [{ "binding": "VINEXT_KV_CACHE", "id": "<your-namespace-id>" }],
+}
 ```
 
-The `CacheHandler` interface matches Next.js 16's shape, so community adapters should be compatible.
+`binding` defaults to `VINEXT_KV_CACHE`, so `kvDataAdapter()` with no options works as long as that's your binding name. Other options: `appPrefix` (namespace cache keys to isolate multiple apps in one KV namespace), `ttlSeconds` (default KV `expirationTtl`, default 30 days), and `tagCacheTtlMs` (in-memory tag-invalidation cache TTL, default 5s). `cdnAdapter()` takes no options — it just needs the Workers Cache, which is always available on Workers.
+
+Each builder returns a plain, serializable `{ adapter, options }` descriptor — **it never touches the Workers runtime**, so nothing throws at build or dev time when bindings aren't available. The actual adapter (and its `env` binding lookup) is instantiated lazily on the first request.
+
+Registration is wired into **every router and runtime** — App Router and Pages Router, on Cloudflare Workers as well as the Node.js server (`vinext start`) and dev. It self-guards (instantiated once per isolate) and is resilient: if an adapter can't initialize on a given runtime (e.g. a KV binding doesn't exist on the Node server), vinext logs a warning and falls back to the default handler instead of failing requests.
+
+To write your own adapter, point a slot at any module by path and default-export a factory that receives `{ env, options }` at runtime and returns a data-cache `CacheHandler` (or a CDN adapter):
+
+```ts
+vinext({
+  cache: {
+    data: {
+      adapter: require.resolve("./my-adapter.js"),
+      options: {
+        /* … */
+      },
+    },
+  },
+});
+```
 
 ## What's NOT supported (and won't be)
 
@@ -563,6 +601,7 @@ These are gaps we'd like to close — distinct from the [intentional exclusions]
 - **Route segment config** — `runtime` and `preferredRegion` are ignored (everything runs in the same environment).
 - **Node.js production server (`vinext start`)** works for testing but is less complete than Workers deployment. Cloudflare Workers is the primary target.
 - **Native Node modules (sharp, resvg, satori, lightningcss, @napi-rs/canvas)** crash Vite's RSC dev environment. Dynamic OG image/icon routes using these work in production builds but not in dev mode. These are auto-stubbed during `vinext deploy`.
+- **`next.config.ts` `baseUrl` bare imports require Vite 8.** A `next.config.ts` that imports a bare specifier resolved through `tsconfig.json`'s `compilerOptions.baseUrl` (e.g. `import { bar } from "bar"` resolving to a local `bar.ts`) relies on Vite 8's native `resolve.tsconfigPaths` (Rolldown/oxc-resolver). On Vite 7 there is no native equivalent, so these imports are not resolved. `compilerOptions.paths` aliases (e.g. `@/foo`) work on both Vite 7 and 8. Note that if a bare import matches both a `baseUrl`-local file and an installed package of the same name, the installed package wins (vinext keeps packages externalized so CJS config plugins like `@next/mdx` keep working).
 
 ## Benchmarks
 
@@ -649,8 +688,6 @@ packages/vinext/
       middleware.ts        # middleware.ts / proxy.ts runner
       metadata-routes.ts  # File-based metadata route scanner
       instrumentation.ts  # instrumentation.ts support
-    cloudflare/
-      kv-cache-handler.ts # Cloudflare KV-backed CacheHandler for ISR
     shims/                # One file per next/* module (33 shims + 6 internal)
     build/
       static-export.ts    # output: 'export' support

package/dist/build/clean-output.d.ts

@@ -10,5 +10,4 @@ type CleanBuildOutputResult = {
 };
 declare function cleanBuildOutput(options: CleanBuildOutputOptions): CleanBuildOutputResult;
 //#endregion
-export { cleanBuildOutput };
-//# sourceMappingURL=clean-output.d.ts.map
+export { cleanBuildOutput };

package/dist/build/clean-output.js

@@ -32,5 +32,3 @@ function cleanBuildOutput(options) {
 }
 //#endregion
 export { cleanBuildOutput };
-
-//# sourceMappingURL=clean-output.js.map

package/dist/build/client-build-config.d.ts

@@ -1,6 +1,19 @@
 import { UserConfig } from "vite";
 
 //#region src/build/client-build-config.d.ts
+type ClientAssetFileNameInfo = {
+  readonly name?: string;
+  readonly names?: readonly string[];
+  readonly originalFileName?: string;
+  readonly originalFileNames?: readonly string[];
+};
+/**
+ * Routes client assets into Next-compatible subtrees: `.css` sources go to
+ * `<assetsDir>/css/`, everything else to `<assetsDir>/media/`. Returned as a
+ * function so it can inspect every source-name candidate Rolldown records for
+ * an asset (a single output asset can carry several `originalFileNames`).
+ */
+declare function createClientAssetFileNames(assetsDir: string): (assetInfo: ClientAssetFileNameInfo) => string;
 /**
  * Create a manualChunks function for client builds.
  *
@@ -38,7 +51,8 @@ declare function createClientManualChunks(shimsDir: string): (id: string) => str
  * compression efficiency — small files restart the compression dictionary,
  * adding ~5-15% wire overhead vs fewer larger chunks.
  */
-declare function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined): {
+declare function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined, assetsDir: string): {
+  assetFileNames: (assetInfo: ClientAssetFileNameInfo) => string;
   manualChunks: (id: string) => string | undefined;
   experimentalMinChunkSize: number;
 };
@@ -115,5 +129,4 @@ type VinextBuildConfigWithLegacy = VinextBuildConfig & {
 declare function getBuildBundlerOptions(build: UserConfig["build"] | undefined): VinextBuildBundlerOptions | undefined;
 declare function withBuildBundlerOptions(viteMajorVersion: number, bundlerOptions: VinextBuildBundlerOptions): Partial<VinextBuildConfigWithLegacy>;
 //#endregion
-export { clientTreeshakeConfig, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
-//# sourceMappingURL=client-build-config.d.ts.map
+export { clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };

package/dist/build/client-build-config.js

@@ -1,4 +1,30 @@
 //#region src/build/client-build-config.ts
+const NEXT_CLIENT_CSS_ASSET_FILE_NAMES = "css/[name].[hash:8][extname]";
+const NEXT_CLIENT_STATIC_MEDIA_FILE_NAMES = "media/[name].[hash:8][extname]";
+function joinAssetFileNamePattern(assetsDir, pattern) {
+	let end = assetsDir.length;
+	while (end > 0 && assetsDir[end - 1] === "/") end -= 1;
+	const normalized = assetsDir.slice(0, end);
+	return normalized ? `${normalized}/${pattern}` : pattern;
+}
+/**
+* Routes client assets into Next-compatible subtrees: `.css` sources go to
+* `<assetsDir>/css/`, everything else to `<assetsDir>/media/`. Returned as a
+* function so it can inspect every source-name candidate Rolldown records for
+* an asset (a single output asset can carry several `originalFileNames`).
+*/
+function createClientAssetFileNames(assetsDir) {
+	const cssAssetFileNames = joinAssetFileNamePattern(assetsDir, NEXT_CLIENT_CSS_ASSET_FILE_NAMES);
+	const mediaAssetFileNames = joinAssetFileNamePattern(assetsDir, NEXT_CLIENT_STATIC_MEDIA_FILE_NAMES);
+	return function getClientAssetFileNames(assetInfo) {
+		return [
+			...assetInfo.names ?? [],
+			assetInfo.name,
+			...assetInfo.originalFileNames ?? [],
+			assetInfo.originalFileName
+		].some((name) => name?.toLowerCase().endsWith(".css")) ? cssAssetFileNames : mediaAssetFileNames;
+	};
+}
 /**
 * Extract the npm package name from a module ID (file path).
 * Returns null if not in node_modules.
@@ -63,8 +89,9 @@ function createClientManualChunks(shimsDir) {
 * compression efficiency — small files restart the compression dictionary,
 * adding ~5-15% wire overhead vs fewer larger chunks.
 */
-function createClientOutputConfig(clientManualChunks) {
+function createClientOutputConfig(clientManualChunks, assetsDir) {
 	return {
+		assetFileNames: createClientAssetFileNames(assetsDir),
 		manualChunks: clientManualChunks,
 		experimentalMinChunkSize: 1e4
 	};
@@ -144,6 +171,4 @@ function withBuildBundlerOptions(viteMajorVersion, bundlerOptions) {
 	return viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
 }
 //#endregion
-export { clientTreeshakeConfig, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
-
-//# sourceMappingURL=client-build-config.js.map
+export { clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };

package/dist/build/css-url-assets.d.ts

@@ -0,0 +1,29 @@
+import { Rolldown } from "vite";
+
+//#region src/build/css-url-assets.d.ts
+type BundleAsset = Rolldown.OutputAsset;
+type CssUrlAssetBundle = Rolldown.OutputBundle;
+type EmitRestoredCssUrlAsset = (asset: {
+  fileName: string;
+  source: BundleAsset["source"];
+}) => void;
+/**
+ * Append the private provenance marker to each relative asset `url()` in a CSS
+ * source. Idempotent and side-effect free (only adds a query param), so it is
+ * safe to run on every client-environment stylesheet, vendored CSS included.
+ */
+declare function markCssUrlAssetReferences(code: string, id: string): string | null;
+/**
+ * Mutates emitted CSS assets in place so byte-identical `url()` dependencies
+ * keep their distinct Next-compatible filenames. Sibling files are produced via
+ * `emitRestoredAsset` (which must call `this.emitFile({ type: "asset", fileName,
+ * source })` — the explicit `fileName` opts out of Rolldown's content dedupe).
+ *
+ * Expects CSS to have been marked by `markCssUrlAssetReferences()` first. The
+ * marker is stripped from all final output here. CSS that Vite inlined into a JS
+ * chunk (`cssCodeSplit: false` / `?inline`) already has final URLs, so chunk
+ * code only has the leaked marker stripped — no sibling files are emitted.
+ */
+declare function restoreDedupedCssAssetReferences(bundle: CssUrlAssetBundle, emitRestoredAsset: EmitRestoredCssUrlAsset): void;
+//#endregion
+export { markCssUrlAssetReferences, restoreDedupedCssAssetReferences };

package/dist/build/css-url-assets.js

@@ -0,0 +1,211 @@
+//#region src/build/css-url-assets.ts
+/**
+* Next-parity for CSS `url()` asset dependencies.
+*
+* Next.js (webpack `asset/resource`) emits one output file per *source* file a
+* stylesheet references, keyed by module identity. Vite/Rolldown instead dedupe
+* emitted assets by *content*: two byte-identical files (`dark.svg`, `dark2.svg`)
+* collapse to a single output, and every `url()` that referenced either source
+* is rewritten to that one filename — so the second filename disappears.
+*
+* There is no config switch to disable that dedupe (it is intentional; see
+* vitejs/vite#8632). The one native escape hatch is `this.emitFile({ fileName })`:
+* assets emitted with an explicit `fileName` are *never* deduped. So we:
+*
+*   1. mark — during the client CSS transform, tag each relative asset `url()`
+*      with a private `?vinext_css_url_asset=<source-basename>` query. This is
+*      the only durable carrier of per-reference provenance: once Rolldown
+*      dedupes, the emitted bundle cannot tell which `url()` came from which
+*      source, and the bundle metadata (`originalFileNames`) records the set of
+*      sources but not the mapping per reference.
+*
+*   2. restore — at `generateBundle`, read each marked reference's source
+*      basename back out. When it differs from the deduped output's basename,
+*      emit a sibling file under that source's name (via the `fileName` escape
+*      hatch) and rewrite the reference to it. The marker is then stripped.
+*
+* Each reference resolves from its own marker, so split CSS chunks stay correct
+* with no shared cursor or bundle-iteration-order dependence.
+*/
+const CSS_URL_ASSET_MARKER = "vinext_css_url_asset";
+const CSS_URL_RE = /url\(\s*(?:"([^"]*)"|'([^']*)'|([^'")]*?))\s*\)/g;
+const CSS_ASSET_EXT_RE = /\.(?:avif|bmp|gif|ico|jpe?g|png|svg|webp|woff2?|eot|ttf|otf|mp4|webm|ogg|mp3|wav|flac|aac|wasm)$/i;
+const CSS_REQUEST_RE = /\.(?:css|scss|sass|less|styl|stylus)(?:\?|$)/i;
+function basename(value) {
+	const normalized = value.replaceAll("\\", "/");
+	const slash = normalized.lastIndexOf("/");
+	return slash === -1 ? normalized : normalized.slice(slash + 1);
+}
+function stem(fileName) {
+	const base = basename(fileName);
+	const dot = base.lastIndexOf(".");
+	return dot <= 0 ? base : base.slice(0, dot);
+}
+function splitUrl(url) {
+	const hashAt = url.indexOf("#");
+	const beforeHash = hashAt === -1 ? url : url.slice(0, hashAt);
+	const hash = hashAt === -1 ? "" : url.slice(hashAt);
+	const queryAt = beforeHash.indexOf("?");
+	if (queryAt === -1) return {
+		path: beforeHash,
+		query: "",
+		hash
+	};
+	return {
+		path: beforeHash.slice(0, queryAt),
+		query: beforeHash.slice(queryAt + 1),
+		hash
+	};
+}
+function joinUrl({ path, query, hash }) {
+	return `${path}${query ? `?${query}` : ""}${hash}`;
+}
+function decodeURIComponentSafe(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function getMarker(query) {
+	for (const part of query.split("&")) {
+		const eq = part.indexOf("=");
+		if ((eq === -1 ? part : part.slice(0, eq)) === CSS_URL_ASSET_MARKER) return eq === -1 ? "" : decodeURIComponentSafe(part.slice(eq + 1));
+	}
+	return null;
+}
+function dropMarker(query) {
+	return query.split("&").filter((part) => (part.indexOf("=") === -1 ? part : part.slice(0, part.indexOf("="))) !== CSS_URL_ASSET_MARKER).join("&");
+}
+function isRelativeAssetUrl(rawPath) {
+	return !(rawPath === "" || rawPath.startsWith("/") || rawPath.startsWith("#") || rawPath.includes("(") || /^[a-zA-Z][\w+.-]*:/.test(rawPath));
+}
+function rewriteUrlToken(match, nextUrl) {
+	if (match[1] !== void 0) return `url("${nextUrl}")`;
+	if (match[2] !== void 0) return `url('${nextUrl}')`;
+	return `url(${nextUrl})`;
+}
+function isCssRequest(id) {
+	return CSS_REQUEST_RE.test(id);
+}
+/** Replace every `url(...)` in `code` whose raw URL `replace()` rewrites. */
+function rewriteCssUrls(code, replace) {
+	let out = "";
+	let last = 0;
+	let changed = false;
+	CSS_URL_RE.lastIndex = 0;
+	let match;
+	while ((match = CSS_URL_RE.exec(code)) !== null) {
+		const rawUrl = match[1] ?? match[2] ?? match[3]?.trim();
+		if (!rawUrl) continue;
+		const next = replace(rawUrl);
+		if (next === null) continue;
+		out += code.slice(last, match.index) + rewriteUrlToken(match, next);
+		last = match.index + match[0].length;
+		changed = true;
+	}
+	return changed ? out + code.slice(last) : null;
+}
+/**
+* Append the private provenance marker to each relative asset `url()` in a CSS
+* source. Idempotent and side-effect free (only adds a query param), so it is
+* safe to run on every client-environment stylesheet, vendored CSS included.
+*/
+function markCssUrlAssetReferences(code, id) {
+	if (!isCssRequest(id) || !code.includes("url(")) return null;
+	return rewriteCssUrls(code, (rawUrl) => {
+		const parts = splitUrl(rawUrl.trim());
+		if (!isRelativeAssetUrl(parts.path)) return null;
+		if (getMarker(parts.query) !== null) return null;
+		const lower = parts.path.toLowerCase();
+		if (!CSS_ASSET_EXT_RE.test(lower) || lower.endsWith(".css")) return null;
+		const param = `${CSS_URL_ASSET_MARKER}=${encodeURIComponent(basename(parts.path))}`;
+		return joinUrl({
+			...parts,
+			query: parts.query ? `${parts.query}&${param}` : param
+		});
+	});
+}
+function isCssFileName(fileName) {
+	return fileName.toLowerCase().endsWith(".css");
+}
+/**
+* Given a deduped output filename (`media/dark.1a2b3c4d.svg`) and the source
+* basename a reference actually wants (`dark2.svg`), produce the sibling output
+* filename (`media/dark2.1a2b3c4d.svg`) by swapping the leading name segment
+* while preserving the hash + extension. `asset.originalFileNames` tells us
+* which source stem the output was named after, so we strip exactly that.
+*/
+function deriveSiblingFileName(asset, desiredBasename) {
+	const fileName = asset.fileName;
+	const slash = fileName.lastIndexOf("/");
+	const dir = slash === -1 ? "" : fileName.slice(0, slash + 1);
+	const outBase = basename(fileName);
+	const desiredStem = stem(desiredBasename);
+	const sourceStems = [
+		...asset.names ?? [],
+		asset.name,
+		...asset.originalFileNames ?? [],
+		asset.originalFileName
+	].filter((n) => !!n).map((n) => stem(n)).sort((a, b) => b.length - a.length);
+	for (const wStem of sourceStems) if (wStem && (outBase === wStem || outBase.startsWith(`${wStem}.`) || outBase.startsWith(`${wStem}-`))) return `${dir}${desiredStem}${outBase.slice(wStem.length)}`;
+	const dot = outBase.indexOf(".");
+	return `${dir}${desiredStem}${dot === -1 ? "" : outBase.slice(dot)}`;
+}
+/**
+* Mutates emitted CSS assets in place so byte-identical `url()` dependencies
+* keep their distinct Next-compatible filenames. Sibling files are produced via
+* `emitRestoredAsset` (which must call `this.emitFile({ type: "asset", fileName,
+* source })` — the explicit `fileName` opts out of Rolldown's content dedupe).
+*
+* Expects CSS to have been marked by `markCssUrlAssetReferences()` first. The
+* marker is stripped from all final output here. CSS that Vite inlined into a JS
+* chunk (`cssCodeSplit: false` / `?inline`) already has final URLs, so chunk
+* code only has the leaked marker stripped — no sibling files are emitted.
+*/
+function restoreDedupedCssAssetReferences(bundle, emitRestoredAsset) {
+	const assetsByBase = /* @__PURE__ */ new Map();
+	for (const entry of Object.values(bundle)) if (entry.type === "asset" && !isCssFileName(entry.fileName)) assetsByBase.set(basename(entry.fileName), entry);
+	const emitted = new Set(Object.keys(bundle));
+	for (const entry of Object.values(bundle)) {
+		if (entry.type === "chunk") {
+			if (typeof entry.code === "string" && entry.code.includes(CSS_URL_ASSET_MARKER)) entry.code = stripChunkMarkers(entry.code);
+			continue;
+		}
+		if (!isCssFileName(entry.fileName) || typeof entry.source !== "string") continue;
+		entry.source = rewriteCssUrls(entry.source, (rawUrl) => {
+			const parts = splitUrl(rawUrl);
+			const desiredBasename = getMarker(parts.query);
+			if (desiredBasename === null) return null;
+			const query = dropMarker(parts.query);
+			const asset = assetsByBase.get(basename(parts.path));
+			if (!asset) return joinUrl({
+				...parts,
+				query
+			});
+			const siblingFileName = deriveSiblingFileName(asset, desiredBasename);
+			if (siblingFileName === asset.fileName) return joinUrl({
+				...parts,
+				query
+			});
+			if (!emitted.has(siblingFileName)) {
+				emitted.add(siblingFileName);
+				emitRestoredAsset({
+					fileName: siblingFileName,
+					source: asset.source
+				});
+			}
+			return joinUrl({
+				path: parts.path.slice(0, parts.path.length - basename(parts.path).length) + basename(siblingFileName),
+				query,
+				hash: parts.hash
+			});
+		}) ?? entry.source;
+	}
+}
+const CSS_URL_MARKER_PARAM_RE = new RegExp(`(\\?)${CSS_URL_ASSET_MARKER}=[^&#'")\\\\\\s]*&|[?&]${CSS_URL_ASSET_MARKER}=[^&#'")\\\\\\s]*`, "g");
+function stripChunkMarkers(code) {
+	return code.replace(CSS_URL_MARKER_PARAM_RE, (_m, leadingQuestion) => leadingQuestion ? leadingQuestion : "");
+}
+//#endregion
+export { markCssUrlAssetReferences, restoreDedupedCssAssetReferences };

package/dist/build/google-fonts/build-url.d.ts

@@ -6,5 +6,4 @@ type FontAxes = {
 };
 declare function buildGoogleFontsUrl(fontFamily: string, axes: FontAxes, display: string): string;
 //#endregion
-export { FontAxes, buildGoogleFontsUrl };
-//# sourceMappingURL=build-url.d.ts.map
+export { FontAxes, buildGoogleFontsUrl };

package/dist/build/google-fonts/build-url.js

@@ -26,5 +26,3 @@ function buildGoogleFontsUrl(fontFamily, axes, display) {
 }
 //#endregion
 export { buildGoogleFontsUrl };
-
-//# sourceMappingURL=build-url.js.map

package/dist/build/google-fonts/fallback-metrics-data.js

@@ -14027,5 +14027,3 @@ var fallback_metrics_data_default = {
 };
 //#endregion
 export { fallback_metrics_data_default as default };
-
-//# sourceMappingURL=fallback-metrics-data.js.map

package/dist/build/google-fonts/fallback-metrics.d.ts

@@ -9,5 +9,4 @@ type AdjustFontFallback = {
 declare function getFallbackFontOverrideMetrics(fontFamily: string): AdjustFontFallback | undefined;
 declare function buildFallbackFontFace(family: string, metrics: AdjustFontFallback): string;
 //#endregion
-export { buildFallbackFontFace, getFallbackFontOverrideMetrics };
-//# sourceMappingURL=fallback-metrics.d.ts.map
+export { buildFallbackFontFace, getFallbackFontOverrideMetrics };

package/dist/build/google-fonts/fallback-metrics.js

@@ -42,5 +42,3 @@ function buildFallbackFontFace(family, metrics) {
 }
 //#endregion
 export { buildFallbackFontFace, getFallbackFontOverrideMetrics };
-
-//# sourceMappingURL=fallback-metrics.js.map

package/dist/build/google-fonts/font-data.js

@@ -24981,5 +24981,3 @@ var font_data_default = {
 };
 //#endregion
 export { font_data_default as default };
-
-//# sourceMappingURL=font-data.js.map

package/dist/build/google-fonts/font-metadata.d.ts

@@ -13,5 +13,4 @@ type FontFamilyMetadata = {
 };
 declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;
 //#endregion
-export { googleFontsMetadata };
-//# sourceMappingURL=font-metadata.d.ts.map
+export { googleFontsMetadata };

package/dist/build/google-fonts/font-metadata.js

@@ -3,5 +3,3 @@ import font_data_default from "./font-data.js";
 const googleFontsMetadata = font_data_default;
 //#endregion
 export { googleFontsMetadata };
-
-//# sourceMappingURL=font-metadata.js.map

package/dist/build/google-fonts/get-axes.d.ts

@@ -3,5 +3,4 @@ import { FontAxes } from "./build-url.js";
 //#region src/build/google-fonts/get-axes.d.ts
 declare function getFontAxes(fontFamily: string, weights: string[], styles: string[], selectedVariableAxes?: string[]): FontAxes;
 //#endregion
-export { getFontAxes };
-//# sourceMappingURL=get-axes.d.ts.map
+export { getFontAxes };

package/dist/build/google-fonts/get-axes.js

@@ -35,5 +35,3 @@ function getFontAxes(fontFamily, weights, styles, selectedVariableAxes) {
 }
 //#endregion
 export { getFontAxes };
-
-//# sourceMappingURL=get-axes.js.map

package/dist/build/google-fonts/sort-variants.d.ts

@@ -1,5 +1,4 @@
 //#region src/build/google-fonts/sort-variants.d.ts
 declare function sortFontsVariantValues(valA: string, valB: string): number;
 //#endregion
-export { sortFontsVariantValues };
-//# sourceMappingURL=sort-variants.d.ts.map
+export { sortFontsVariantValues };

package/dist/build/google-fonts/sort-variants.js

@@ -10,5 +10,3 @@ function sortFontsVariantValues(valA, valB) {
 }
 //#endregion
 export { sortFontsVariantValues };
-
-//# sourceMappingURL=sort-variants.js.map

package/dist/build/google-fonts/validate.d.ts

@@ -24,5 +24,4 @@ type ValidatedGoogleFontOptions = {
 };
 declare function validateGoogleFontOptions(fontFamily: string, options: GoogleFontOptions): ValidatedGoogleFontOptions;
 //#endregion
-export { validateGoogleFontOptions };
-//# sourceMappingURL=validate.d.ts.map
+export { validateGoogleFontOptions };

package/dist/build/google-fonts/validate.js

@@ -52,5 +52,3 @@ function validateGoogleFontOptions(fontFamily, options) {
 }
 //#endregion
 export { validateGoogleFontOptions };
-
-//# sourceMappingURL=validate.js.map

package/dist/build/inline-css.d.ts

@@ -3,5 +3,4 @@ type InlineCssManifest = Record<string, string>;
 declare function collectInlineCssManifest(clientDir: string, assetPrefix: string): InlineCssManifest;
 declare function injectInlineCssManifestGlobal(entryPath: string, manifest: InlineCssManifest): boolean;
 //#endregion
-export { collectInlineCssManifest, injectInlineCssManifestGlobal };
-//# sourceMappingURL=inline-css.d.ts.map
+export { collectInlineCssManifest, injectInlineCssManifestGlobal };

package/dist/build/inline-css.js

@@ -46,5 +46,3 @@ function injectInlineCssManifestGlobal(entryPath, manifest) {
 }
 //#endregion
 export { collectInlineCssManifest, injectInlineCssManifestGlobal };
-
-//# sourceMappingURL=inline-css.js.map

package/dist/build/layout-classification-types.d.ts

@@ -58,5 +58,4 @@ type LayoutBuildClassification = {
   reason: ClassificationReason;
 };
 //#endregion
-export { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason };
-//# sourceMappingURL=layout-classification-types.d.ts.map
+export { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason };

package/dist/build/layout-classification.d.ts

@@ -49,12 +49,11 @@ declare function isStaticModuleGraphResult(graphResult: ModuleGraphClassificatio
  * Shared layouts (same file appearing in multiple routes) are classified once
  * and deduplicated by layout ID.
  *
- * @internal Not called by production code. The `generateBundle` hook in
+ * @internal Not called by production code. The `renderChunk` hook in
  * `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
  * via the numeric-index manifest in `route-classification-manifest.ts`.
  * Used only by `tests/layout-classification.test.ts`.
  */
 declare function classifyAllRouteLayouts(routes: readonly RouteForClassification[], dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): Map<string, LayoutBuildClassification>;
 //#endregion
-export { ModuleInfoProvider, classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };
-//# sourceMappingURL=layout-classification.d.ts.map
+export { ModuleInfoProvider, classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };

package/dist/build/layout-classification.js

@@ -68,7 +68,7 @@ function isStaticModuleGraphResult(graphResult) {
 * Shared layouts (same file appearing in multiple routes) are classified once
 * and deduplicated by layout ID.
 *
-* @internal Not called by production code. The `generateBundle` hook in
+* @internal Not called by production code. The `renderChunk` hook in
 * `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
 * via the numeric-index manifest in `route-classification-manifest.ts`.
 * Used only by `tests/layout-classification.test.ts`.
@@ -96,5 +96,3 @@ function classifyAllRouteLayouts(routes, dynamicShimPaths, moduleInfo) {
 }
 //#endregion
 export { classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };
-
-//# sourceMappingURL=layout-classification.js.map

package/dist/build/next-client-runtime-manifests.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedNextConfig } from "../config/next-config.js";
+
+//#region src/build/next-client-runtime-manifests.d.ts
+type EmitNextClientRuntimeManifestsOptions = {
+  clientDir: string;
+  assetsSubdir: string;
+  buildId: string;
+  rewrites: ResolvedNextConfig["rewrites"];
+};
+declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"]): string;
+declare function buildNextClientSsgManifestContent(): string;
+declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
+//#endregion
+export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests };