bosia 1.1.4 → 1.1.5

package/src/core/client/page.svelte.ts

@@ -8,8 +8,14 @@
 // App.svelte), mirroring the modern SvelteKit `$app/state` direction. Route
 // components should destructure `params` from `$props()`. `page.params` was
 // removed in 1.1.0.
+//
+// `page.route.id` is the matched route's folder path with groups kept
+// (`/(private)/dashboard/[id]`), the same id hooks and loaders get. `null` when
+// no route matches, e.g. on the 404 page.
 
 import { router } from "./router.svelte.ts";
+import { findMatch } from "../matcher.ts";
+import { clientRoutes } from "bosia:routes";
 
 class Page {
 	// Real on the server too: the renderer seeds `router.currentRoute`/`.origin`
@@ -18,12 +24,21 @@ class Page {
 	// render that seeded nothing at all — a bare unit test, never a served request.
 	#url = $derived.by(() => new URL(router.currentRoute, router.origin || "http://localhost/"));
 
+	// clientRoutes carry the BASE_PATH prefix, and so does `router.currentRoute`
+	// (the renderer puts it back before SSR), so the pathname matches as-is.
+	#route = $derived.by(() => ({
+		id: findMatch(clientRoutes, this.#url.pathname)?.route.id ?? null,
+	}));
+
 	get url() {
 		return this.#url;
 	}
 	get pathname() {
 		return this.#url.pathname;
 	}
+	get route() {
+		return this.#route;
+	}
 }
 
 export const page = new Page();

package/src/core/client/prefetch.ts

@@ -10,8 +10,9 @@ import { base } from "./base.ts";
 
 /**
  * Build the `_invalidated` mask bits for a target path using the current
- * client loader cache. Char 0 = page, char i+1 = layout depth i; '1' = run,
- * '0' = skip. Returns `null` when the route cannot be matched.
+ * client loader cache. Char 0 = page, char i+1 = layout depth i; '1' = send,
+ * '0' = the client already holds it (the server still runs layout loaders,
+ * since they may be guards). Returns `null` when the route cannot be matched.
  */
 export function buildMaskBits(path: string): string | null {
 	const url = new URL(path, window.location.origin);
@@ -42,37 +43,10 @@ export function buildMaskBits(path: string): string | null {
 }
 
 /**
- * Build `parentSnapshots` (layout depth → cached data) for a target path from
- * the current loader cache, given the mask bits from `buildMaskBits`. For each
- * layout depth whose mask bit is '0' (skipped) and whose cached entry exists,
- * forward that layer's data so server-side downstream loaders see real
- * `parent()` data instead of `{}`. Returns `{}` when nothing to carry.
- *
- * Client-supplied perf hint only — the server never trusts it for authz.
+ * Builds the `/__bosia/data/…` URL for a given client path. `fresh` marks a
+ * fetch that follows an `invalidate()`, so the server skips its cached copy.
  */
-export function buildParentSnapshots(
-	path: string,
-	maskBits: string,
-): Record<number, Record<string, any>> {
-	const snapshots: Record<number, Record<string, any>> = {};
-	const url = new URL(path, window.location.origin);
-	const match = findMatch(clientRoutes, url.pathname);
-	if (!match) return snapshots;
-	const layoutIds = (match.route as any).layoutIds as (string | null)[];
-
-	layoutIds.forEach((id, depth) => {
-		// maskBits char 0 = page, char depth+1 = layout depth. '0' = skipped.
-		if (maskBits[depth + 1] !== "0") return;
-		if (id === null) return;
-		const entry = appState.loaderCache.layouts[id];
-		if (entry) snapshots[depth] = entry.data;
-	});
-
-	return snapshots;
-}
-
-/** Builds the `/__bosia/data/…` URL for a given client path. */
-export function dataUrl(path: string, invalidatedBits?: string): string {
+export function dataUrl(path: string, invalidatedBits?: string, fresh = false): string {
 	const url = new URL(path, window.location.origin);
 	let p = url.pathname.replace(/\/$/, "");
 	let qs = url.search;
@@ -80,6 +54,7 @@ export function dataUrl(path: string, invalidatedBits?: string): string {
 		const sep = qs ? "&" : "?";
 		qs = `${qs}${sep}_invalidated=${invalidatedBits}`;
 	}
+	if (fresh) qs = `${qs}${qs ? "&" : "?"}_fresh=1`;
 	// The one place a path is still taken apart, and it is URL construction rather
 	// than navigation: the data endpoint is `<base>/__bosia/data` + the *app* path,
 	// so the mount prefix moves from the front of the route to the front of the
@@ -151,35 +126,39 @@ export function consumePrefetch(path: string): any | null {
 
 /** Prefetches data for a path and stores in cache. No-op if already cached/in-flight. */
 export async function prefetchPath(path: string): Promise<void> {
+	// Nothing to fetch for the page we're on. A click also focuses its link, so
+	// the focusin trigger fires ~100ms after the navigation it belongs to.
+	if (path === window.location.pathname + window.location.search) return;
 	// Warm the route's +loading.svelte chunk alongside its data, so the skeleton
 	// paints instantly on click instead of cold-importing after the old page lingers.
 	const warmMatch = findMatch(clientRoutes, new URL(path, window.location.origin).pathname);
-	(warmMatch?.route as { loading?: (() => Promise<unknown>) | null } | undefined)?.loading?.();
+	// Also warm the page and layout chunks: a route not visited yet otherwise
+	// downloads its code only after the click. Errors are swallowed — a stale
+	// chunk is the click's to report, not the hover's (hydrate.ts reloads on it).
+	if (warmMatch) {
+		const route = warmMatch.route as typeof warmMatch.route & {
+			loading?: (() => Promise<unknown>) | null;
+		};
+		for (const load of [route.loading, route.page, ...route.layouts]) {
+			load?.().catch(() => {});
+		}
+	}
 
 	const existing = prefetchCache.get(path);
 	if (existing && Date.now() - existing.ts <= 30_000) return;
 	if (existing) prefetchCache.delete(path);
 	if (pending.has(path)) return;
 
+	// A route without server data never fetches on click either.
+	if (!warmMatch?.route.hasServerData) return;
+
 	pending.add(path);
 	try {
-		// Send the same mask as a real client nav would so the server can skip
-		// loaders whose tracked inputs haven't changed. Falls back to running
-		// everything when the route can't be matched (e.g. external/unknown URL).
+		// Send the same mask as a real client nav would so the server leaves out
+		// layers the client already holds. Falls back to sending everything when
+		// the route can't be matched (e.g. external/unknown URL).
 		const maskBits = buildMaskBits(path) ?? undefined;
-		// Forward cached parent data for skipped layers so a prefetched response
-		// is computed with real parent() data, not {}. POST only when there's
-		// something to carry — keeps the no-skip case a cacheable/dedupable GET.
-		const snapshots = maskBits ? buildParentSnapshots(path, maskBits) : {};
-		const init: RequestInit =
-			Object.keys(snapshots).length > 0
-				? {
-						method: "POST",
-						headers: { "Content-Type": "application/json" },
-						body: JSON.stringify({ parentSnapshots: snapshots }),
-					}
-				: {};
-		const res = await fetch(dataUrl(path, maskBits), init);
+		const res = await fetch(dataUrl(path, maskBits));
 		// `ok` alone would cache a guard's login page (200 after the redirect was
 		// followed) as if it were this route's data.
 		if (res.ok && !res.redirected && isJsonResponse(res)) {
@@ -228,23 +207,39 @@ function observeViewportLinks(container: Element | Document = document) {
 	return observer;
 }
 
+/** The link a hover/touch/focus event is on, when it sits under `data-bosia-preload="hover"`. */
+function hoverLinkHref(target: EventTarget | null): string | null {
+	if (!(target instanceof Element)) return null;
+	// Early exit: skip if no [data-bosia-preload="hover"] ancestor exists
+	const preloadEl = target.closest("[data-bosia-preload]");
+	if (!preloadEl || preloadEl.getAttribute("data-bosia-preload") !== "hover") return null;
+	const anchor = target.closest("a") as HTMLAnchorElement | null;
+	return anchor ? getLinkHref(anchor) : null;
+}
+
 export function initPrefetch(): void {
-	// ── Hover strategy (event delegation, 20ms debounce) ─────
+	// ── Hover strategy (event delegation, 100ms debounce) ────
 	let hoverTimer: ReturnType<typeof setTimeout> | null = null;
 
-	document.addEventListener("mouseover", (e) => {
-		if (!(e.target instanceof Element)) return;
-		// Early exit: skip if no [data-bosia-preload="hover"] ancestor exists
-		const preloadEl = e.target.closest("[data-bosia-preload]");
-		if (!preloadEl || preloadEl.getAttribute("data-bosia-preload") !== "hover") return;
-		const anchor = e.target.closest("a") as HTMLAnchorElement | null;
-		if (!anchor) return;
-		const href = getLinkHref(anchor);
+	const onIntent = (e: Event) => {
+		const href = hoverLinkHref(e.target);
 		if (!href) return;
-
 		if (hoverTimer) clearTimeout(hoverTimer);
 		hoverTimer = setTimeout(() => prefetchPath(href), 100);
-	});
+	};
+	document.addEventListener("mouseover", onIntent);
+	// Keyboard users tab onto a link before pressing Enter — same signal.
+	document.addEventListener("focusin", onIntent);
+	// Touch screens have no hover; a touch is followed by the click within
+	// ~100ms or not at all, so start right away instead of debouncing.
+	document.addEventListener(
+		"touchstart",
+		(e) => {
+			const href = hoverLinkHref(e.target);
+			if (href) prefetchPath(href);
+		},
+		{ passive: true },
+	);
 
 	document.addEventListener("mouseout", () => {
 		if (hoverTimer) {

package/src/core/dev.ts

@@ -1,5 +1,5 @@
 import { spawn, type Subprocess } from "bun";
-import { readdirSync, statSync, watch, type Dirent } from "fs";
+import { readdirSync, rmSync, statSync, watch, type Dirent } from "fs";
 import { join } from "path";
 import { loadEnv } from "./env.ts";
 import { BOSIA_NODE_PATH } from "./paths.ts";
@@ -12,6 +12,12 @@ import { affectsRouteManifest, shouldIgnoreForRebuild } from "./devWatch.ts";
 // but dev.ts itself never reads it.
 const DEV_OUT_DIR = ".bosia/dev";
 
+// Compiled-component cache shared by every rebuild in this session (see
+// svelteCompiler.ts). Outside DEV_OUT_DIR, which each build clears. Emptied
+// here, once per `bosia dev`, so it only ever holds this session's entries.
+const SVELTE_CACHE_DIR = ".bosia/cache/svelte";
+rmSync(SVELTE_CACHE_DIR, { recursive: true, force: true });
+
 // Snapshot pure shell env BEFORE any loadEnv call pollutes process.env.
 // On `.env*` change we restore from this snapshot, then re-run loadEnv,
 // so removed/renamed keys no longer linger in the dev process.
@@ -142,6 +148,10 @@ async function runBuild(): Promise<boolean> {
 			...process.env,
 			BOSIA_OUT_DIR: DEV_OUT_DIR,
 			BOSIA_SKIP_ROUTE_SCAN: skipScan ? "1" : "0",
+			// The dev server never serves prerendered pages or dist/static, so the
+			// build skips producing them (~25% of a rebuild on the demo).
+			BOSIA_DEV_BUILD: "1",
+			BOSIA_SVELTE_CACHE_DIR: SVELTE_CACHE_DIR,
 		},
 	});
 	return (await proc.exited) === 0;

package/src/core/etag.ts

@@ -0,0 +1,13 @@
+// ─── ETag matching ───────────────────────────────────────
+// Shared by static files (staticManifest.ts) and cached responses (cache.ts).
+// No runtime imports: cache.ts also runs on Cloudflare Workers.
+
+/** True when an `If-None-Match` header names `etag` (or `*`). Weak tags match too. */
+export function matchesEtag(header: string | null, etag: string): boolean {
+	if (!header) return false;
+	for (const raw of header.split(",")) {
+		const t = raw.trim();
+		if (t === "*" || t === etag || (t.startsWith("W/") && t.slice(2) === etag)) return true;
+	}
+	return false;
+}

package/src/core/hooks.ts

@@ -58,6 +58,19 @@ export type RequestEvent = {
 	 */
 	locals: Record<string, any> & { nonce?: string };
 	params: Record<string, string>;
+	/**
+	 * The matched route. `id` is its folder under `src/routes` with groups kept,
+	 * e.g. `"/(private)/dashboard/[id]"`; `null` when nothing matched. Set before
+	 * `handle` runs, for page, client-navigation data, form and API requests
+	 * alike, so one check guards a whole group:
+	 *
+	 * ```ts
+	 * if (event.route.id?.startsWith("/(private)") && !event.locals.user) {
+	 * 	throw redirect(303, "/login");
+	 * }
+	 * ```
+	 */
+	route: { id: string | null };
 	cookies: Cookies;
 	/**
 	 * True when the client router is fetching this page's loader data for a
@@ -79,6 +92,8 @@ export type RequestEvent = {
 export type LoadEvent = {
 	url: URL;
 	params: Record<string, string>;
+	/** The route being rendered; see `RequestEvent.route`. */
+	route: { id: string };
 	locals: Record<string, any>;
 	cookies: Cookies;
 	fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
@@ -169,6 +184,8 @@ export type Handle = (input: {
 
 export type MetadataEvent = {
 	params: Record<string, string>;
+	/** The route being rendered; see `RequestEvent.route`. */
+	route: { id: string };
 	url: URL;
 	locals: Record<string, any>;
 	cookies: Cookies;

package/src/core/html.ts

@@ -62,18 +62,84 @@ export function baseScript(nonce?: string): string {
  *  no buster (same reason as ENTRY). Unknown pattern or an older dist/ without
  *  the `preload` field → nothing, and the page loads as it did before. */
 export function routePreloadLinks(pattern?: string): string {
-	if (!pattern) return "";
-	return (distManifest.preload?.[pattern] ?? [])
-		.map((f) => `\n  <link rel="modulepreload" href="${DIST}/${f}">`)
-		.join("");
+	const preload = distManifest.preload;
+	if (!pattern || !preload) return "";
+	let byPattern = preloadLinks.get(preload);
+	if (!byPattern) preloadLinks.set(preload, (byPattern = new Map()));
+	let links = byPattern.get(pattern);
+	if (links === undefined) {
+		links = (preload[pattern] ?? [])
+			.map((f) => `\n  <link rel="modulepreload" href="${DIST}/${f}">`)
+			.join("");
+		byPattern.set(pattern, links);
+	}
+	return links;
+}
+
+// One header value per route pattern (plus "" for no pattern), built on first
+// use. Bounded by the number of routes.
+const linkHeaders = new Map<string, string>();
+
+/**
+ * `Link` response header naming the stylesheets and, when the page hydrates,
+ * the client entry and the route's chunks. The document lists the same files,
+ * but a CDN that sends 103 Early Hints (Cloudflare) reads them off this header
+ * and lets the browser start downloading while the loaders still run.
+ * Prod only — dev URLs carry a cache buster and nothing sits in front.
+ */
+export function preloadLinkHeader(pattern: string | undefined, csr: boolean): string | null {
+	if (isDev) return null;
+	const key = `${csr ? "1" : "0"}${pattern ?? ""}`;
+	let value = linkHeaders.get(key);
+	if (value === undefined) {
+		const tw = distManifest.tw ? `${DIST}/${distManifest.tw}` : TW_CSS;
+		const parts = [tw, ...(distManifest.css ?? []).map((f) => `${DIST}/${f}`)].map(
+			(href) => `<${href}>; rel=preload; as=style`,
+		);
+		if (csr) {
+			const scripts = [
+				ENTRY,
+				...(distManifest.preload?.[pattern ?? ""] ?? []).map((f) => `${DIST}/${f}`),
+			];
+			for (const href of scripts) parts.push(`<${href}>; rel=modulepreload`);
+		}
+		value = parts.join(", ");
+		linkHeaders.set(key, value);
+	}
+	return value;
 }
 
+/** `extra` with the preload `Link` header added — after any `link` a loader set. */
+export function withPreloadLink(
+	extra: Record<string, string> | undefined,
+	pattern: string | undefined,
+	csr: boolean,
+): Record<string, string> | undefined {
+	const link = preloadLinkHeader(pattern, csr);
+	if (!link) return extra;
+	const own = extra?.["link"];
+	return { ...extra, link: own ? `${own}, ${link}` : link };
+}
+
+// The head fragments below are the same on every request, so each is built
+// once and reused for as long as the manifest field it reads stays the same
+// object (tests swap them out).
+const preloadLinks = new WeakMap<object, Map<string, string>>();
+
 /** Tailwind stylesheet link. Content-hashed name needs no cache buster — the
  *  hash IS the buster. Fallback keeps older dist/ artifacts (no `tw` field) styled. */
+let twLink: { tw: string | undefined; html: string } | null = null;
 function twCssLink(): string {
-	return distManifest.tw
-		? `<link rel="stylesheet" href="${DIST}/${distManifest.tw}">`
-		: `<link rel="stylesheet" href="${TW_CSS}${cacheBust}">`;
+	const tw = distManifest.tw;
+	if (!twLink || twLink.tw !== tw) {
+		twLink = {
+			tw,
+			html: tw
+				? `<link rel="stylesheet" href="${DIST}/${tw}">`
+				: `<link rel="stylesheet" href="${TW_CSS}${cacheBust}">`,
+		};
+	}
+	return twLink.html;
 }
 
 /** The build-time component stylesheet (scoped `<style>` blocks, concatenated).
@@ -83,10 +149,18 @@ function twCssLink(): string {
  *  is settled on source order. Linking before Tailwind would silently flip
  *  which one wins. Each entry carries its own indent and newline, so an app with
  *  no scoped styles at all contributes nothing rather than a blank line. */
+let cssLinks: { css: string[] | undefined; html: string } | null = null;
 function componentCssLinks(): string {
-	return (distManifest.css ?? [])
-		.map((f: string) => `  <link rel="stylesheet" href="${DIST}/${f}">\n`)
-		.join("");
+	const css = distManifest.css;
+	if (!cssLinks || cssLinks.css !== css) {
+		cssLinks = {
+			css,
+			html: (css ?? [])
+				.map((f: string) => `  <link rel="stylesheet" href="${DIST}/${f}">\n`)
+				.join(""),
+		};
+	}
+	return cssLinks.html;
 }
 
 /** Inline theme bootstrap — runs before paint to avoid FOUC. theme ∈ light|dark|system (missing = system). */
@@ -464,17 +538,28 @@ export function disableCompression(): void {
 // Shared, stateless — one instance instead of a fresh allocation per response.
 const textEncoder = new TextEncoder();
 
-export type Encoding = "br" | "gzip";
+/** Encodings stored ahead of time — cache entries and build-time static files. */
+export type StoredEncoding = "br" | "gzip";
+export type Encoding = StoredEncoding | "zstd";
 
-/** Best encoding the client accepts — brotli over gzip, null for identity.
+/** Best stored encoding the client accepts — brotli over gzip, null for identity.
  *  A substring check, not q-value parsing: no browser sends `br;q=0`. */
-export function pickEncoding(accept: string | null): Encoding | null {
+export function pickEncoding(accept: string | null): StoredEncoding | null {
 	if (!accept) return null;
 	if (accept.includes("br")) return "br";
 	if (accept.includes("gzip")) return "gzip";
 	return null;
 }
 
+/** Best encoding for a body compressed on the spot. zstd comes first: at
+ *  level 3 it matches brotli q3's size on an HTML page in about half the CPU
+ *  (55µs vs 95µs for 7KB). Current Chrome and Firefox send it; everyone else
+ *  falls back to `pickEncoding`. */
+export function pickRequestEncoding(accept: string | null): Encoding | null {
+	if (accept?.includes("zstd")) return "zstd";
+	return pickEncoding(accept);
+}
+
 // Per-request brotli runs once per response, so it favors speed: q3 is ~2x
 // faster than q5 for ~5–25% bigger output. Cached variants are built once and
 // served many times, so they take q5. 11 (the default) would block the event
@@ -485,6 +570,10 @@ const BROTLI = {
 	cache: { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5 } },
 };
 
+// Bun's native gzip is ~40% faster than node:zlib's at the same level and
+// size. Workers has no `Bun`, but never compresses (see compressionOn).
+const hasBun = typeof Bun !== "undefined";
+
 /** The one place runtime compression quality is set — cache.ts builds its
  *  stored variants through here too. gzip keeps zlib's default level. */
 export function encodeBytes(
@@ -492,6 +581,9 @@ export function encodeBytes(
 	enc: Encoding,
 	quality: Quality = "request",
 ): Uint8Array<ArrayBuffer> {
+	if (enc === "zstd") return Bun.zstdCompressSync(bytes, { level: 3 }) as Uint8Array<ArrayBuffer>;
+	if (enc === "gzip" && hasBun)
+		return Bun.gzipSync(bytes as Uint8Array<ArrayBuffer>) as Uint8Array<ArrayBuffer>;
 	const out = enc === "br" ? brotliCompressSync(bytes, BROTLI[quality]) : gzipSync(bytes);
 	return new Uint8Array(out) as Uint8Array<ArrayBuffer>;
 }
@@ -504,7 +596,10 @@ export function encodeForRequest(
 	req: Request,
 	quality: Quality = "request",
 ): Encoded | null {
-	const enc = pickEncoding(req.headers.get("accept-encoding"));
+	const accept = req.headers.get("accept-encoding");
+	// A cache-quality body is also stored in the cache entry, which only keeps
+	// brotli and gzip copies — so it never picks zstd.
+	const enc = quality === "cache" ? pickEncoding(accept) : pickRequestEncoding(accept);
 	// Skip compression in dev — the dev proxy's fetch() auto-decompresses gzip
 	// responses but keeps the Content-Encoding header, causing ERR_CONTENT_DECODING_FAILED.
 	if (!compressionOn || isDev || !enc || bytes.length <= GZIP_MIN_BYTES) return null;

package/src/core/plugins/inspector/bun-plugin.ts

@@ -2,7 +2,7 @@ import { parse, compile } from "svelte/compiler";
 import MagicString from "magic-string";
 import { relative } from "node:path";
 import type { BunPlugin } from "bun";
-import { svelteMapCache } from "../../svelteCompiler.ts";
+import { cachedCompile, svelteMapCache } from "../../svelteCompiler.ts";
 import { lineColFromOffset } from "../../sourceLoc.ts";
 import { toPosix } from "../../paths.ts";
 import { collectComponentCss } from "../../componentCss.ts";
@@ -133,21 +133,35 @@ export function createInspectorBunPlugin(opts: InspectorBunPluginOptions): BunPl
 				const rel = toPosix(relative(cwd, args.path));
 				const transformed = injectLocs(source, rel);
 
-				const result = compile(transformed, {
-					filename: args.path,
-					generate,
-					dev,
-					hmr: dev,
-					// Mirror the prod compiler (svelteCompiler.ts): external on both
-					// targets, with the client's rules harvested into one stylesheet
-					// that the head links. This plugin registers ahead of the main
-					// compiler and its onLoad wins in dev, so letting the two drift
-					// here is how dev and prod stop agreeing about first paint.
-					css: "external",
-					preserveWhitespace: dev,
-					preserveComments: dev,
-					cssHash: ({ css }) => `svelte-${fnv(css)}`,
-				});
+				// Reused across `bosia dev` rebuilds when nothing it depends on changed
+				// (see cachedCompile in svelteCompiler.ts).
+				const { value: result } = await cachedCompile(
+					["inspector", args.path, generate, dev, transformed],
+					() => {
+						const out = compile(transformed, {
+							filename: args.path,
+							generate,
+							dev,
+							hmr: dev,
+							// Mirror the prod compiler (svelteCompiler.ts): external on both
+							// targets, with the client's rules harvested into one stylesheet
+							// that the head links. This plugin registers ahead of the main
+							// compiler and its onLoad wins in dev, so letting the two drift
+							// here is how dev and prod stop agreeing about first paint.
+							css: "external",
+							preserveWhitespace: dev,
+							preserveComments: dev,
+							cssHash: ({ css }) => `svelte-${fnv(css)}`,
+						});
+						return {
+							js: {
+								code: out.js.code,
+								map: typeof out.js.map === "string" ? JSON.parse(out.js.map) : out.js.map,
+							},
+							css: out.css ? { code: out.css.code } : null,
+						};
+					},
+				);
 
 				// Store Svelte's compile-step map. Bun's bundler doesn't chain
 				// onLoad sourcemaps, so the final bundle map resolves stack frames
@@ -164,8 +178,7 @@ export function createInspectorBunPlugin(opts: InspectorBunPluginOptions): BunPl
 				// line numbers differ. The resolver translates browser-side stack
 				// frames (delivered via SSE), which run client code.
 				if (dev && generate === "client" && result.js.map) {
-					const m = typeof result.js.map === "string" ? JSON.parse(result.js.map) : result.js.map;
-					svelteMapCache.set(args.path, m);
+					svelteMapCache.set(args.path, result.js.map);
 				}
 
 				// Client only — see the same guard in svelteCompiler.ts.