vinext 0.0.55 → 0.1.1

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)
 
@@ -650,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/assets-ignore.d.ts

@@ -0,0 +1,32 @@
+//#region src/build/assets-ignore.d.ts
+/**
+ * Build metadata that must never be served by the Cloudflare ASSETS binding.
+ *
+ * On Cloudflare Workers the ASSETS binding serves any uploaded file whose path
+ * matches the request BEFORE the Worker runs, so anything written into the
+ * client output directory (`dist/client`) is publicly fetchable unless excluded.
+ * Vite writes its build/SSR manifests under `dist/client/.vite/` (enabled for
+ * Cloudflare builds so the worker entry can compute lazy chunks), which would
+ * otherwise expose the full source-file → chunk mapping — including the paths of
+ * routes that are never linked from the UI.
+ *
+ * The Node production server already blocks `/.vite/` explicitly
+ * (see `server/static-file-cache.ts`); `.assetsignore` is the equivalent guard
+ * for the Cloudflare deployment target. wrangler matches `.assetsignore`
+ * patterns with `.gitignore` semantics (via the `ignore` package), so the bare
+ * `.vite` entry excludes the directory and everything beneath it.
+ */
+declare const DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS: readonly string[];
+/**
+ * Ensure a `.assetsignore` in `clientDir` contains every pattern in `patterns`.
+ *
+ * Any pre-existing (user-authored) content is preserved verbatim and only the
+ * missing patterns are appended, so the result is idempotent across rebuilds
+ * and never clobbers a `.assetsignore` the developer wrote themselves.
+ *
+ * @returns `true` when the file was created or modified, `false` when it already
+ *          covered every requested pattern.
+ */
+declare function ensureAssetsIgnore(clientDir: string, patterns?: readonly string[]): boolean;
+//#endregion
+export { DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS, ensureAssetsIgnore };

package/dist/build/assets-ignore.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/assets-ignore.ts
+/**
+* Build metadata that must never be served by the Cloudflare ASSETS binding.
+*
+* On Cloudflare Workers the ASSETS binding serves any uploaded file whose path
+* matches the request BEFORE the Worker runs, so anything written into the
+* client output directory (`dist/client`) is publicly fetchable unless excluded.
+* Vite writes its build/SSR manifests under `dist/client/.vite/` (enabled for
+* Cloudflare builds so the worker entry can compute lazy chunks), which would
+* otherwise expose the full source-file → chunk mapping — including the paths of
+* routes that are never linked from the UI.
+*
+* The Node production server already blocks `/.vite/` explicitly
+* (see `server/static-file-cache.ts`); `.assetsignore` is the equivalent guard
+* for the Cloudflare deployment target. wrangler matches `.assetsignore`
+* patterns with `.gitignore` semantics (via the `ignore` package), so the bare
+* `.vite` entry excludes the directory and everything beneath it.
+*/
+const DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS = [".vite"];
+/** wrangler reads asset-exclusion patterns from this file in the assets dir. */
+const ASSETS_IGNORE_FILENAME = ".assetsignore";
+const GENERATED_HEADER = "# Keep build metadata out of the deployed asset bundle (generated by vinext)";
+/**
+* Ensure a `.assetsignore` in `clientDir` contains every pattern in `patterns`.
+*
+* Any pre-existing (user-authored) content is preserved verbatim and only the
+* missing patterns are appended, so the result is idempotent across rebuilds
+* and never clobbers a `.assetsignore` the developer wrote themselves.
+*
+* @returns `true` when the file was created or modified, `false` when it already
+*          covered every requested pattern.
+*/
+function ensureAssetsIgnore(clientDir, patterns = DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS) {
+	const assetsIgnorePath = path.join(clientDir, ASSETS_IGNORE_FILENAME);
+	const existing = fs.existsSync(assetsIgnorePath) ? fs.readFileSync(assetsIgnorePath, "utf-8") : null;
+	const present = new Set((existing ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+	const missing = patterns.filter((pattern) => !present.has(pattern));
+	if (missing.length === 0) return false;
+	const lines = existing && existing.trim().length > 0 ? [existing.replace(/\s*$/, "")] : [GENERATED_HEADER];
+	lines.push(...missing, "");
+	fs.mkdirSync(clientDir, { recursive: true });
+	fs.writeFileSync(assetsIgnorePath, lines.join("\n"));
+	return true;
+}
+//#endregion
+export { DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS, ensureAssetsIgnore };

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;
 };
@@ -48,6 +62,32 @@ declare function createClientCodeSplittingConfig(clientManualChunks: (id: string
     name(moduleId: string): string | null;
   }[];
 };
+/**
+ * Regex matching any {@link FRAMEWORK_PACKAGES} package inside `node_modules`.
+ * Derived from the package list so the regex and {@link isRscFrameworkModule}
+ * predicate can't drift.
+ */
+declare const RSC_FRAMEWORK_CHUNK_TEST: RegExp;
+declare function isRscFrameworkModule(id: string): boolean;
+/**
+ * Output config that isolates React (and the RSC flight runtime) into a
+ * dedicated "framework" chunk in the RSC server build. Returns the bundler-
+ * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
+ * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
+ * motivation (issue #1549).
+ */
+declare function createRscFrameworkChunkOutputConfig(viteMajorVersion: number): {
+  codeSplitting: {
+    groups: {
+      name: string;
+      test: RegExp;
+    }[];
+  };
+  manualChunks?: undefined;
+} | {
+  manualChunks(id: string): string | undefined;
+  codeSplitting?: undefined;
+};
 /**
  * Rollup treeshake configuration for production client builds.
  *
@@ -115,5 +155,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 { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, 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
 	};
@@ -78,6 +105,63 @@ function createClientCodeSplittingConfig(clientManualChunks) {
 	};
 }
 /**
+* Matches React framework packages (and the RSC flight runtime) inside
+* `node_modules`. Used to split them into a dedicated "framework" chunk in the
+* RSC server build.
+*
+* Why the RSC build needs this: without an explicit framework chunk, the
+* bundler colocates React into whichever chunk first reaches it — typically the
+* RSC entry chunk, which also carries the root layout's CSS. Modules that only
+* import React for runtime helpers (notably `app/global-not-found.tsx`, which
+* replaces the root layout for route-miss 404s) then import that entry chunk
+* and inherit the root layout's CSS in their `serverResources` metadata. The
+* 404 document ends up linking the layout's stylesheet last, so the layout's
+* rules win the cascade over global-not-found's — the bug tracked in
+* https://github.com/cloudflare/vinext/issues/1549.
+*
+* Splitting React into its own (CSS-free) chunk means global-not-found imports
+* the framework chunk instead of the layout-bearing entry chunk, so it no
+* longer inherits the root layout's CSS. The match list mirrors the client
+* build's `framework` chunk, plus `react-server-dom-webpack` for the RSC flight
+* runtime that the server environment bundles.
+*
+* Uses `[\\/]` rather than `/` for the path separator so it matches on Windows
+* too, per the rolldown `codeSplitting` docs.
+*/
+const FRAMEWORK_PACKAGES = [
+	"react",
+	"react-dom",
+	"scheduler",
+	"react-server-dom-webpack"
+];
+/**
+* Regex matching any {@link FRAMEWORK_PACKAGES} package inside `node_modules`.
+* Derived from the package list so the regex and {@link isRscFrameworkModule}
+* predicate can't drift.
+*/
+const RSC_FRAMEWORK_CHUNK_TEST = new RegExp(`[\\\\/]node_modules[\\\\/](${FRAMEWORK_PACKAGES.join("|")})[\\\\/]`);
+function isRscFrameworkModule(id) {
+	if (!id.includes("node_modules")) return false;
+	const pkg = getPackageName(id);
+	return pkg !== null && FRAMEWORK_PACKAGES.includes(pkg);
+}
+/**
+* Output config that isolates React (and the RSC flight runtime) into a
+* dedicated "framework" chunk in the RSC server build. Returns the bundler-
+* appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
+* `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
+* motivation (issue #1549).
+*/
+function createRscFrameworkChunkOutputConfig(viteMajorVersion) {
+	if (viteMajorVersion >= 8) return { codeSplitting: { groups: [{
+		name: "framework",
+		test: RSC_FRAMEWORK_CHUNK_TEST
+	}] } };
+	return { manualChunks(id) {
+		return isRscFrameworkModule(id) ? "framework" : void 0;
+	} };
+}
+/**
 * Rollup treeshake configuration for production client builds.
 *
 * Uses the 'recommended' preset as a safe base, then overrides
@@ -144,6 +228,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 { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, 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 };