@svelte-vitals/core 0.55.2 → 0.55.3

package/dist/{markdown-DgHBAvYl.js → markdown-CsQNXeWj.js}

@@ -152,6 +152,168 @@ const seoTitlePresence = {
 	}
 };
 //#endregion
+//#region src/kit-module.ts
+/** The root layout — its page options cover the whole app. */
+const ROOT_LAYOUT_RE = /^src\/routes\/\+layout(\.server)?\.(ts|js)$/;
+/** Files whose `ssr` export is a page option — it has no effect in `+server` endpoints or hooks files. */
+const PAGE_OPTION_FILE_RE = /\+(page|layout)(\.server)?\.(ts|js)$/;
+const appSsrCache = /* @__PURE__ */ new WeakMap();
+/**
+* Whether no page is ever server-rendered: the hash router, or a root layout exporting `ssr = false`
+* that no page-option file might turn back on. Universal loads and components then run only in the
+* browser; server files (`+page.server`, `+server`, hooks) still run on the server.
+*/
+function appSsrDisabled(scope) {
+	if (scope.project?.kitHashRouter) return true;
+	const kitModules = scope.kitModules;
+	if (!kitModules) return false;
+	let hit = appSsrCache.get(kitModules);
+	if (hit === void 0) {
+		hit = kitModules.some((m) => m.ssrDisabled && ROOT_LAYOUT_RE.test(m.file)) && !kitModules.some((m) => PAGE_OPTION_FILE_RE.test(m.file) && (m.ssrEnabled || m.parseFailed));
+		appSsrCache.set(kitModules, hit);
+	}
+	return hit;
+}
+const ROUTES_DIR$1 = "src/routes";
+/** A `+page`/`+layout` file: its directory, kind, and the `@segment` layout reset (on `.svelte` names). */
+const ROUTE_FILE_RE = /^(src\/routes(?:\/.+)?)\/\+(page|layout)(?:@([^/]*))?(?:\.server)?\.(?:svelte|ts|js)$/;
+const parentDir = (dir) => dir === ROUTES_DIR$1 ? void 0 : dir.slice(0, dir.lastIndexOf("/"));
+/** The nearest ancestor-or-self directory a `@segment` reset names (`''` is the root). */
+function resetTarget(dir, segment) {
+	for (let d = dir; d !== void 0; d = parentDir(d)) if (segment === "" ? d === ROUTES_DIR$1 : d.slice(d.lastIndexOf("/") + 1) === segment) return d;
+}
+const routeOptionCache = {
+	ssr: /* @__PURE__ */ new WeakMap(),
+	csr: /* @__PURE__ */ new WeakMap()
+};
+const optionOn = (m, option) => m.parseFailed || (option === "ssr" ? m.ssrEnabled : m.csrEnabled);
+const optionOff = (m, option) => (option === "ssr" ? m.ssrDisabled : m.csrDisabled) !== void 0;
+/**
+* Per route directory, whether `ssr` or `csr` is off for its page (`page:<dir>`) or layout
+* (`layout:<dir>`). A page takes the nearest export of the option along its own files and then its
+* layout chain, following `+page@x`/`+layout@x` resets as SvelteKit does; an export other than
+* `false` (or `dev`), or an unparsed option file, counts as on. A layout is off only when every page
+* using it is — and the root layout also needs its own opt-out, since it wraps the 404 page.
+*/
+function routeOptionOff(scope, which) {
+	const kitModules = scope.kitModules ?? [];
+	let hit = routeOptionCache[which].get(scope);
+	if (hit) return hit;
+	const own = {
+		universal: /* @__PURE__ */ new Map(),
+		server: /* @__PURE__ */ new Map()
+	};
+	for (const m of kitModules) {
+		const match = ROUTE_FILE_RE.exec(m.file);
+		if (!match) continue;
+		const key = `${match[2]}:${match[1]}`;
+		if (optionOn(m, which)) own[m.kind].set(key, "on");
+		else if (optionOff(m, which)) own[m.kind].set(key, "off");
+	}
+	const option = new Map([...own.server, ...own.universal]);
+	hit = /* @__PURE__ */ new Map();
+	for (const [dir, chain] of pageChains(scope)) {
+		const off = [`page:${dir}`, ...chain.map((l) => `layout:${l}`)].map((k) => option.get(k)).find(Boolean) === "off";
+		hit.set(`page:${dir}`, off);
+		for (const l of chain) hit.set(`layout:${l}`, (hit.get(`layout:${l}`) ?? true) && off);
+	}
+	if (option.get(`layout:${ROUTES_DIR$1}`) !== "off") hit.delete(`layout:${ROUTES_DIR$1}`);
+	routeOptionCache[which].set(scope, hit);
+	return hit;
+}
+const chainCache = /* @__PURE__ */ new WeakMap();
+/** Per page directory, the layout directories that wrap it, nearest first, following `+page@x`/`+layout@x` resets as SvelteKit does. */
+function pageChains(scope) {
+	let hit = chainCache.get(scope);
+	if (hit) return hit;
+	const pages = /* @__PURE__ */ new Map();
+	const layouts = /* @__PURE__ */ new Map();
+	const files = [
+		...scope.sourceFiles ?? [],
+		...(scope.components ?? []).map((c) => c.file),
+		...(scope.kitModules ?? []).map((m) => m.file)
+	];
+	for (const file of files) {
+		const match = ROUTE_FILE_RE.exec(file);
+		if (!match) continue;
+		const map = match[2] === "page" ? pages : layouts;
+		if (match[3] !== void 0 || !map.has(match[1])) map.set(match[1], match[3]);
+	}
+	hit = /* @__PURE__ */ new Map();
+	for (const [dir, reset] of pages) {
+		const chain = [];
+		for (let d = reset === void 0 ? dir : resetTarget(dir, reset); d !== void 0;) {
+			const layoutReset = layouts.get(d);
+			if (layouts.has(d)) chain.push(d);
+			d = layoutReset === void 0 ? parentDir(d) : resetTarget(parentDir(d), layoutReset);
+		}
+		hit.set(dir, chain);
+	}
+	chainCache.set(scope, hit);
+	return hit;
+}
+/** Whether a `+page` file's route sends requests without a session away: its own load or a wrapping layout's does (`loadGated`). */
+function routeGated(file, scope) {
+	const match = ROUTE_FILE_RE.exec(file);
+	if (!match || match[2] !== "page") return false;
+	const gated = /* @__PURE__ */ new Set();
+	for (const m of scope.kitModules ?? []) {
+		const g = m.loadGated && m.kind === "server" ? ROUTE_FILE_RE.exec(m.file) : null;
+		if (g) gated.add(`${g[2]}:${g[1]}`);
+	}
+	if (gated.size === 0) return false;
+	const chain = pageChains(scope).get(match[1]) ?? [];
+	return gated.has(`page:${match[1]}`) || chain.some((l) => gated.has(`layout:${l}`));
+}
+/**
+* Whether a `+page` file's route never renders because a layout above it redirects or errors in its
+* `load` on every call (`loadNeverRenders`). Not the root layout: one that sent every request away
+* would leave the app nothing to serve, so that reading is more likely wrong than the app, and acting
+* on it would silence every route.
+*/
+function layoutNeverRenders(file, scope) {
+	const match = ROUTE_FILE_RE.exec(file);
+	if (!match || match[2] !== "page") return false;
+	const dead = /* @__PURE__ */ new Set();
+	for (const m of scope.kitModules ?? []) {
+		const layout = m.loadNeverRenders ? ROUTE_FILE_RE.exec(m.file) : null;
+		if (layout?.[2] === "layout" && layout[1] !== ROUTES_DIR$1) dead.add(layout[1]);
+	}
+	return dead.size > 0 && (pageChains(scope).get(match[1]) ?? []).some((dir) => dead.has(dir));
+}
+/**
+* Whether a `+page` file's route never renders because its own `load` redirects or errors on every
+* request, a build-time `if (building)` aside (`loadNeverRendersOutsideBuild`), and nothing on its chain
+* exports `prerender`, so the build never renders it either.
+*/
+function pageRendersOnlyWhenBuilding(file, scope) {
+	const match = ROUTE_FILE_RE.exec(file);
+	if (!match || match[2] !== "page") return false;
+	const at = (m) => ROUTE_FILE_RE.exec(m.file);
+	const modules = scope.kitModules ?? [];
+	if (!modules.some((m) => m.loadNeverRendersOutsideBuild && at(m)?.[2] === "page" && at(m)?.[1] === match[1])) return false;
+	const layouts = /* @__PURE__ */ new Set([match[1], ...pageChains(scope).get(match[1]) ?? []]);
+	return !modules.some((m) => {
+		const where = m.prerenderExported ? at(m) : null;
+		return !!where && (where[2] === "page" ? where[1] === match[1] : layouts.has(where[1]));
+	});
+}
+/** Whether a `+page`/`+layout` file (module or component) belongs to a route that is never server-rendered. */
+function routeNeverSsr(file, scope) {
+	const match = ROUTE_FILE_RE.exec(file);
+	return !!match && (appSsrDisabled(scope) || routeOptionOff(scope, "ssr").get(`${match[2]}:${match[1]}`) === true);
+}
+/** Whether a universal `+page`/`+layout` module never runs in the browser: every page it serves has `csr` off, its own or inherited. */
+function universalNeverCsr(m, scope) {
+	if (m.kind !== "universal") return false;
+	const match = ROUTE_FILE_RE.exec(m.file);
+	return !!match && routeOptionOff(scope, "csr").get(`${match[2]}:${match[1]}`) === true;
+}
+/** Whether a universal `+page`/`+layout` module never runs on the server — its own `ssr = false`, an app-wide one, or one its route inherits. */
+function universalNeverSsr(m, scope) {
+	return m.kind === "universal" && (m.ssrDisabled !== void 0 || appSsrDisabled(scope) || routeNeverSsr(m.file, scope));
+}
+//#endregion
 //#region src/rules/seo/head-tag-rule.ts
 /** Open Graph keys are read from `property=`; `name="og:*"` is the common slip. */
 function ogMisspelled(key) {
@@ -179,6 +341,7 @@ function detect(head, match) {
 		value: "absent"
 	};
 }
+const GATED_NOTE = "Reported as info: this route's load turns away visitors without a session (a redirect or a 401/403), so search engines never index it.";
 /** Build a route-scope rule asserting the presence of a single head tag (design §11). */
 function headTagRule(opts) {
 	const docsUrl = docsUrlFor(opts.id);
@@ -195,15 +358,16 @@ function headTagRule(opts) {
 				const detection = detect(head, opts.match);
 				const misspelled = detection.presence === "none" && opts.misspelled && head.tags.some(opts.misspelled.match) ? opts.misspelled : void 0;
 				const message = misspelled ? misspelled.label : detection.presence === "none" ? `Missing ${opts.label}` : detection.value === "absent" ? `Empty ${opts.label}` : opts.label;
+				const gated = opts.infoWhenGated && routeGated(head.file, ctx);
 				return {
 					id: opts.id,
 					category: "seo",
-					severity: opts.severity,
+					severity: gated ? "info" : opts.severity,
 					detection,
 					route: head.route,
 					location: head.file,
 					message,
-					recommendation: misspelled?.recommendation ?? opts.recommendation,
+					recommendation: misspelled?.recommendation ?? (gated ? `${opts.recommendation} ${GATED_NOTE}` : opts.recommendation),
 					docsUrl,
 					...misspelled ? { fix: { ...misspelled.fix } } : opts.fix ? { fix: { ...opts.fix } } : {}
 				};
@@ -217,6 +381,7 @@ const seoDescriptionPresence = headTagRule({
 	id: "seo/description-presence",
 	title: "Description presence",
 	severity: "warning",
+	infoWhenGated: true,
 	match: (t) => t.kind === "meta" && t.name === "description",
 	label: "<meta name=\"description\">",
 	recommendation: "Add a <meta name=\"description\"> in <svelte:head>, or set the description on your meta component.",
@@ -228,12 +393,50 @@ const seoDescriptionPresence = headTagRule({
 	}
 });
 //#endregion
+//#region src/head.ts
+/** Whether a `<link>`'s `rel` holds `token`: `rel` is a set of space-separated keywords (`dns-prefetch preconnect`). */
+function hasRel(tag, token) {
+	return tag.rel?.split(/\s+/).includes(token) ?? false;
+}
+const JS_MIME_TYPES = /* @__PURE__ */ new Set([
+	"application/ecmascript",
+	"application/javascript",
+	"application/x-ecmascript",
+	"application/x-javascript",
+	"text/ecmascript",
+	"text/javascript",
+	"text/javascript1.0",
+	"text/javascript1.1",
+	"text/javascript1.2",
+	"text/javascript1.3",
+	"text/javascript1.4",
+	"text/javascript1.5",
+	"text/jscript",
+	"text/livescript",
+	"text/x-ecmascript",
+	"text/x-javascript"
+]);
+/** HTML strips only ASCII whitespace from a `type` before matching — `trim()` would also strip
+*  U+00A0 etc. and misread a data block as a classic script. */
+const ASCII_WHITESPACE_EDGES = /^[\t\n\f\r ]+|[\t\n\f\r ]+$/g;
+/**
+* Whether a `type` attribute (undefined = absent) makes a `<script>` a classic,
+* render-blocking-capable script. Per the HTML spec, absent and the literal empty string are
+* classic; any other value is ASCII-whitespace-stripped and must match a JavaScript MIME type —
+* so a whitespace-only `type` is a data block, not a classic script.
+*/
+function isClassicScriptType(type) {
+	if (type === void 0 || type === "") return true;
+	return JS_MIME_TYPES.has(type.replace(ASCII_WHITESPACE_EDGES, "").toLowerCase());
+}
+//#endregion
 //#region src/rules/seo/canonical-url.ts
 const seoCanonicalUrl = headTagRule({
 	id: "seo/canonical-url",
 	title: "Canonical URL",
 	severity: "warning",
-	match: (t) => t.kind === "link" && t.rel === "canonical",
+	infoWhenGated: true,
+	match: (t) => t.kind === "link" && hasRel(t, "canonical"),
 	label: "<link rel=\"canonical\">",
 	recommendation: "Add <link rel=\"canonical\"> in <svelte:head>, or set the canonical prop on your meta component.",
 	rationale: "A canonical URL tells search engines which URL is authoritative, preventing duplicate-content dilution across query-string variants of the same page.",
@@ -557,7 +760,7 @@ const performancePreloadMissingAs = linkRule({
 		snippet: "<link rel=\"preload\" href=\"/app.css\" as=\"style\" />",
 		lang: "html"
 	},
-	relevant: (t) => t.rel === "preload",
+	relevant: (t) => hasRel(t, "preload"),
 	ok: (t) => t.hasAs === true
 });
 //#endregion
@@ -574,7 +777,7 @@ const performanceFontPreloadCrossorigin = linkRule({
 		snippet: "<link rel=\"preload\" href=\"/inter.woff2\" as=\"font\" type=\"font/woff2\" crossorigin />",
 		lang: "html"
 	},
-	relevant: (t) => t.rel === "preload" && t.as === "font",
+	relevant: (t) => hasRel(t, "preload") && t.as === "font",
 	ok: (t) => t.hasCrossorigin === true
 });
 //#endregion
@@ -663,7 +866,8 @@ const performanceRenderBlockingScript = {
 	async check(ctx) {
 		const out = [];
 		for (const head of ctx.heads) {
-			const scripts = head.tags.filter((t) => t.kind === "script");
+			const clientHead = routeNeverSsr(head.file, ctx);
+			const scripts = head.tags.filter((t) => t.kind === "script" && !(clientHead && t.file !== "src/app.html"));
 			if (scripts.length === 0) continue;
 			const blocking = scripts.filter((t) => t.blocking);
 			if (blocking.length > 0) for (const tag of blocking) out.push({
@@ -1175,7 +1379,7 @@ const performancePreconnect = {
 				if (tag.kind !== "link" && tag.kind !== "script" || typeof tag.href !== "string") continue;
 				const host = hostOf(tag.href);
 				if (!host) continue;
-				if (tag.kind === "link" && (tag.rel === "preconnect" || tag.rel === "dns-prefetch")) {
+				if (tag.kind === "link" && (hasRel(tag, "preconnect") || hasRel(tag, "dns-prefetch"))) {
 					covered.add(host);
 					continue;
 				}
@@ -2060,7 +2264,7 @@ const seoHreflang = {
 	async check(ctx) {
 		const out = [];
 		for (const head of ctx.heads) {
-			const alternates = head.tags.filter((t) => t.kind === "link" && t.rel === "alternate" && typeof t.hreflang === "string");
+			const alternates = head.tags.filter((t) => t.kind === "link" && hasRel(t, "alternate") && typeof t.hreflang === "string");
 			if (alternates.length === 0) continue;
 			const values = alternates.map((t) => t.hreflang);
 			const badTag = alternates.find((t) => !isValidHreflang(t.hreflang));
@@ -2342,7 +2546,7 @@ const multipleRecommendation = "A single, clear <h1> is the conventional signal
 * `<svelte:boundary>` contribute only their largest arm. Separate blocks still sum, since both may be true.
 */
 function renderableH1s(headings) {
-	const nodes = headings.filter((h) => h.level === 1).map((heading) => ({
+	const nodes = headings.filter((h) => h.level === 1 && !h.aria).map((heading) => ({
 		key: "h1",
 		path: heading.path ?? [],
 		repeatable: false,
@@ -2371,7 +2575,7 @@ const seoSingleH1 = {
 					severity: "warning",
 					recommendation: missingRecommendation
 				};
-				const first = route.headings[0];
+				const first = route.headings.find((h) => !h.aria);
 				if (first) where = {
 					location: first.file,
 					...first.line > 0 ? { line: first.line } : {}
@@ -2496,6 +2700,12 @@ const seoDuplicateDescription = uniquenessRule({
 });
 //#endregion
 //#region src/headings.ts
+/** Sort comparator for `order`: element by element, a prefix first; headings without one keep their place. */
+function documentOrder(a, b) {
+	if (!a.order || !b.order) return 0;
+	for (let i = 0; i < Math.min(a.order.length, b.order.length); i++) if (a.order[i] !== b.order[i]) return a.order[i] - b.order[i];
+	return a.order.length - b.order.length;
+}
 /** Two headings can never render together: different arms of one block. */
 function exclusiveHeadings(a, b) {
 	if (!a.path || !b.path) return false;
@@ -2504,6 +2714,8 @@ function exclusiveHeadings(a, b) {
 //#endregion
 //#region src/rules/seo/heading-level-skip.ts
 const docsUrl$5 = docsUrlFor("seo/heading-level-skip");
+/** Every arm `p` sits in that can be skipped, `h` sits in too: whenever `h` renders, so does `p` (or one like it). */
+const rendersWith = (p, h) => (p.path ?? []).every((s) => s.always || (h.path ?? []).some((t) => t.group === s.group && t.branch === s.branch));
 const recommendation$5 = "Increase heading levels one step at a time (do not jump, e.g. from <h2> straight to <h4>).";
 /**
 * seo/heading-level-skip — Skipped heading level. Walking a route's body headings in
@@ -2522,13 +2734,33 @@ const seoHeadingLevelSkip = {
 		const out = [];
 		for (const route of ctx.headings ?? []) {
 			if (route.headings.length === 0) continue;
+			const placed = (route.componentHeadings ?? []).filter((h) => h.order);
+			const own = new Set(route.headings);
+			const headings = [...route.headings, ...placed].sort(documentOrder);
 			let skip;
-			for (let i = 1; i < route.headings.length && !skip; i++) {
-				const h = route.headings[i];
-				const prev = route.headings.slice(0, i).reverse().find((p) => !exclusiveHeadings(p, h));
-				if (prev && h.level > prev.level + 1) skip = {
+			for (let i = 1; i < headings.length && !skip; i++) {
+				const h = headings[i];
+				if (!own.has(h)) continue;
+				const before = headings.slice(0, i).filter((p) => !exclusiveHeadings(p, h) && (own.has(p) || rendersWith(p, h)));
+				const prev = before.at(-1);
+				if (!prev) continue;
+				const levels = [prev.level];
+				const arms = /* @__PURE__ */ new Set();
+				const looped = prev.path?.some((s) => s.repeat && !h.path?.some((t) => t.group === s.group));
+				for (let j = looped ? -1 : before.length - 2; j >= 0; j--) {
+					const q = before[j];
+					const step = q.path?.find((s) => prev.path?.some((t) => t.group === s.group && t.branch !== s.branch));
+					const arm = step && `${step.group}:${step.branch}`;
+					if (arm && !arms.has(arm)) {
+						arms.add(arm);
+						levels.push(q.level);
+					}
+				}
+				const known = levels.filter((level) => level > 0);
+				const lowest = Math.min(...known);
+				if (known.length === levels.length && h.level > lowest + 1) skip = {
 					level: h.level,
-					prev: prev.level,
+					prev: lowest,
 					line: h.line,
 					file: h.file
 				};
@@ -2661,93 +2893,6 @@ function kitModuleRule(opts) {
 	});
 }
 //#endregion
-//#region src/kit-module.ts
-/** The root layout — its page options cover the whole app. */
-const ROOT_LAYOUT_RE = /^src\/routes\/\+layout(\.server)?\.(ts|js)$/;
-/** Files whose `ssr` export is a page option — it has no effect in `+server` endpoints or hooks files. */
-const PAGE_OPTION_FILE_RE = /\+(page|layout)(\.server)?\.(ts|js)$/;
-const appSsrCache = /* @__PURE__ */ new WeakMap();
-/**
-* Whether no page is ever server-rendered: the root layout exports `ssr = false` and no page-option
-* file might turn it back on. Universal loads and components then run only in the browser; server
-* files (`+page.server`, `+server`, hooks) still run on the server.
-*/
-function appSsrDisabled(kitModules) {
-	if (!kitModules) return false;
-	let hit = appSsrCache.get(kitModules);
-	if (hit === void 0) {
-		hit = kitModules.some((m) => m.ssrDisabled && ROOT_LAYOUT_RE.test(m.file)) && !kitModules.some((m) => PAGE_OPTION_FILE_RE.test(m.file) && (m.ssrEnabled || m.parseFailed));
-		appSsrCache.set(kitModules, hit);
-	}
-	return hit;
-}
-const ROUTES_DIR$1 = "src/routes";
-/** A `+page`/`+layout` file: its directory, kind, and the `@segment` layout reset (on `.svelte` names). */
-const ROUTE_FILE_RE = /^(src\/routes(?:\/.+)?)\/\+(page|layout)(?:@([^/]*))?(?:\.server)?\.(?:svelte|ts|js)$/;
-const parentDir = (dir) => dir === ROUTES_DIR$1 ? void 0 : dir.slice(0, dir.lastIndexOf("/"));
-/** The nearest ancestor-or-self directory a `@segment` reset names (`''` is the root). */
-function resetTarget(dir, segment) {
-	for (let d = dir; d !== void 0; d = parentDir(d)) if (segment === "" ? d === ROUTES_DIR$1 : d.slice(d.lastIndexOf("/") + 1) === segment) return d;
-}
-const routeSsrCache = /* @__PURE__ */ new WeakMap();
-/**
-* Per route directory, whether its page (`page:<dir>`) or layout (`layout:<dir>`) is never
-* server-rendered. A page takes the nearest `ssr` export along its own files and then its layout
-* chain, following `+page@x`/`+layout@x` resets as SvelteKit does; an export other than a literal
-* `false`, or an unparsed option file, counts as SSR on. A layout is off only when every page using
-* it is — and the root layout also needs its own `ssr = false`, since it wraps the 404 page.
-*/
-function routeSsrOff(scope) {
-	const kitModules = scope.kitModules ?? [];
-	let hit = routeSsrCache.get(scope);
-	if (hit) return hit;
-	const pages = /* @__PURE__ */ new Map();
-	const layouts = /* @__PURE__ */ new Map();
-	const files = [
-		...scope.sourceFiles ?? [],
-		...(scope.components ?? []).map((c) => c.file),
-		...kitModules.map((m) => m.file)
-	];
-	for (const file of files) {
-		const match = ROUTE_FILE_RE.exec(file);
-		if (!match) continue;
-		const map = match[2] === "page" ? pages : layouts;
-		if (match[3] !== void 0 || !map.has(match[1])) map.set(match[1], match[3]);
-	}
-	const option = /* @__PURE__ */ new Map();
-	for (const m of kitModules) {
-		const match = ROUTE_FILE_RE.exec(m.file);
-		if (!match) continue;
-		const key = `${match[2]}:${match[1]}`;
-		if (m.ssrEnabled || m.parseFailed) option.set(key, "on");
-		else if (m.ssrDisabled && !option.has(key)) option.set(key, "off");
-	}
-	hit = /* @__PURE__ */ new Map();
-	for (const [dir, reset] of pages) {
-		const chain = [];
-		for (let d = reset === void 0 ? dir : resetTarget(dir, reset); d !== void 0;) {
-			const layoutReset = layouts.get(d);
-			if (layouts.has(d)) chain.push(d);
-			d = layoutReset === void 0 ? parentDir(d) : resetTarget(parentDir(d), layoutReset);
-		}
-		const off = [`page:${dir}`, ...chain.map((l) => `layout:${l}`)].map((k) => option.get(k)).find(Boolean) === "off";
-		hit.set(`page:${dir}`, off);
-		for (const l of chain) hit.set(`layout:${l}`, (hit.get(`layout:${l}`) ?? true) && off);
-	}
-	if (option.get(`layout:${ROUTES_DIR$1}`) !== "off") hit.delete(`layout:${ROUTES_DIR$1}`);
-	routeSsrCache.set(scope, hit);
-	return hit;
-}
-/** Whether a `+page`/`+layout` file (module or component) belongs to a route that is never server-rendered. */
-function routeNeverSsr(file, scope) {
-	const match = ROUTE_FILE_RE.exec(file);
-	return !!match && routeSsrOff(scope).get(`${match[2]}:${match[1]}`) === true;
-}
-/** Whether a universal `+page`/`+layout` module never runs on the server — its own `ssr = false`, an app-wide one, or one its route inherits. */
-function universalNeverSsr(m, scope) {
-	return m.kind === "universal" && (m.ssrDisabled !== void 0 || appSsrDisabled(scope.kitModules) || routeNeverSsr(m.file, scope));
-}
-//#endregion
 //#region src/rules/seo/ssr-disabled.ts
 const seoSsrDisabled = kitModuleRule({
 	id: "seo/ssr-disabled",
@@ -3244,7 +3389,7 @@ const correctnessInstanceBrowserGlobal = componentRule({
 	label: "Server-safe component init",
 	recommendation: "Move browser-only code into onMount or $effect (they never run on the server), or guard it with browser from $app/environment (or a typeof check).",
 	rationale: "A component instance script runs on the server on every SSR render, where window/document/localStorage do not exist. Warning, not critical: a component rendered only behind a parent {#if browser} (or a client-only dynamic import) is a legitimate pattern that static analysis cannot prove cross-file.",
-	applies: (c, _o, ctx) => (c.browserGlobalRefs ?? []).some((r) => r.context === "instance") && !appSsrDisabled(ctx.kitModules) && !routeNeverSsr(c.file, ctx),
+	applies: (c, _o, ctx) => (c.browserGlobalRefs ?? []).some((r) => r.context === "instance") && !appSsrDisabled(ctx) && !routeNeverSsr(c.file, ctx),
 	bad: (c) => (c.browserGlobalRefs ?? []).filter((r) => r.context === "instance").map((r) => ({
 		line: r.line,
 		message: `${r.name} is accessed during component initialisation — during SSR this runs on the server, where ${r.name} is not defined`
@@ -3432,7 +3577,8 @@ const PREPROCESSED_STYLE_RE = /(<style\b[^>]*\slang\s*=\s*['"]?[^'"\s>]+['"]?[^>
 * the text scan's imprecision cannot reach it. A file that does not parse is already a hard failure,
 * which the retry can only improve on.
 */
-function parseSvelte(source, filename) {
+function parseSvelte(raw, filename) {
+	const source = raw.charCodeAt(0) === 65279 ? ` ${raw.slice(1)}` : raw;
 	try {
 		return parse(source, {
 			modern: true,
@@ -3498,12 +3644,25 @@ function attrValue(attributes, name) {
 	const attr = findAttr(attributes, name);
 	return attr ? attrValueOf(attr) : "absent";
 }
+const lineStarts = /* @__PURE__ */ new Map();
 function lineOf(source, offset) {
 	if (typeof offset !== "number" || offset < 0) return 0;
-	let line = 1;
+	let starts = lineStarts.get(source);
+	if (!starts) {
+		starts = [0];
+		for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) starts.push(i + 1);
+		if (lineStarts.size >= 8) lineStarts.delete(lineStarts.keys().next().value);
+		lineStarts.set(source, starts);
+	}
 	const end = Math.min(offset, source.length);
-	for (let i = 0; i < end; i++) if (source[i] === "\n") line++;
-	return line;
+	let lo = 0;
+	let hi = starts.length;
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		if (starts[mid] <= end) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
 }
 /**
 * An element's attribute by name, matched **case-insensitively**: HTML attribute names are, so
@@ -3536,7 +3695,7 @@ function attrTextOf(attr) {
 //#region src/module-ast.ts
 function unwrapTs(expr) {
 	let cur = expr;
-	while (cur !== void 0 && (cur.type === "TSSatisfiesExpression" || cur.type === "TSAsExpression" || cur.type === "TSNonNullExpression")) cur = cur.expression;
+	while (cur != null && (cur.type === "TSSatisfiesExpression" || cur.type === "TSAsExpression" || cur.type === "TSNonNullExpression")) cur = cur.expression;
 	return cur;
 }
 /** AST metadata keys every walker skips — never traversed as child nodes. Shared with the Kit-module parser (the security kit-module rules). */
@@ -3589,8 +3748,8 @@ function addBoundNames(id, acc) {
 }
 /** The base identifier name of a (possibly nested) member expression or identifier, else undefined. Shared with the Kit-module parser (the security kit-module rules). */
 function rootObjectName(node) {
-	let cur = node;
-	while (cur?.type === "MemberExpression") cur = cur.object;
+	let cur = unwrapTs(node);
+	while (cur?.type === "MemberExpression") cur = unwrapTs(cur.object);
 	return cur?.type === "Identifier" ? cur.name : void 0;
 }
 /**
@@ -3842,6 +4001,11 @@ function collectProgramBindings(program) {
 			for (const s of stmt.specifiers ?? []) if (s?.local?.type === "Identifier") bound.add(s.local.name);
 			continue;
 		}
+		if (stmt?.type === "LabeledStatement" && stmt.label?.name === "$") {
+			const e = stmt.body?.type === "ExpressionStatement" ? stmt.body.expression : void 0;
+			if (e?.type === "AssignmentExpression" && e.operator === "=") addBoundNames(e.left, bound);
+			continue;
+		}
 		const decl = unwrapExport(stmt);
 		if (decl?.type === "VariableDeclaration") for (const d of decl.declarations ?? []) addBoundNames(d?.id, bound);
 		else if ((decl?.type === "FunctionDeclaration" || decl?.type === "ClassDeclaration") && decl.id?.type === "Identifier") bound.add(decl.id.name);
@@ -3886,6 +4050,13 @@ function isBrowserGuardTest(test, guardBindings) {
 	});
 	return guarded;
 }
+/** The tracked global `G` of a `typeof G === 'undefined'` test: the test is false only where `G` is defined. */
+function missingGlobalOf(n) {
+	if (n?.type !== "BinaryExpression" || n.operator !== "===" && n.operator !== "==") return void 0;
+	const sides = [n.left, n.right];
+	if (!sides.some((s) => s?.type === "Literal" && s.value === "undefined")) return void 0;
+	return sides.find((s) => s?.type === "UnaryExpression" && s.operator === "typeof" && s.argument?.type === "Identifier" && BROWSER_GLOBALS.has(s.argument.name))?.argument.name;
+}
 /**
 * Names of derived guard bindings (one level, no fixpoint chasing): a top-level
 * (export-unwrapped) `const`/`let` declarator whose init passes `isBrowserGuardTest` —
@@ -3905,6 +4076,95 @@ function collectDerivedGuardBindings(program, guards) {
 	}
 	return derived;
 }
+const DOM_ONLY_GLOBALS = /* @__PURE__ */ new Set(["window", "document"]);
+/**
+* Unlike `isBrowserGuardTest` this keeps the polarity and each outcome apart, because a write the
+* guard leaves reachable on the server must still be reported: `!browser && url.search` being falsy
+* proves nothing.
+*/
+function guardImplies(test, guards, shadowed) {
+	if (test?.type === "Identifier") return !shadowed.has(test.name) && guards.get(test.name) || {};
+	if (test?.type === "UnaryExpression" && test.operator === "!") {
+		const inner = guardImplies(test.argument, guards, shadowed);
+		return {
+			truthy: inner.falsy,
+			falsy: inner.truthy
+		};
+	}
+	if (test?.type === "LogicalExpression" && (test.operator === "&&" || test.operator === "||")) {
+		const a = guardImplies(test.left, guards, shadowed);
+		const b = guardImplies(test.right, guards, shadowed);
+		const agree = (x, y) => x === y ? x : void 0;
+		return test.operator === "&&" ? {
+			truthy: a.truthy ?? b.truthy,
+			falsy: agree(a.falsy, b.falsy)
+		} : {
+			truthy: agree(a.truthy, b.truthy),
+			falsy: a.falsy ?? b.falsy
+		};
+	}
+	if (test?.type === "BinaryExpression" && [
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(test.operator)) {
+		const sides = [test.left, test.right];
+		const hasTypeofGlobal = sides.some((s) => s?.type === "UnaryExpression" && s.operator === "typeof" && s.argument?.type === "Identifier" && DOM_ONLY_GLOBALS.has(s.argument.name) && !shadowed.has(s.argument.name));
+		const type = sides.find((s) => s?.type === "Literal" && typeof s.value === "string")?.value;
+		if (!hasTypeofGlobal || type === void 0) return {};
+		const equal = test.operator === "===" || test.operator === "==";
+		if (type === "undefined") return equal ? {
+			truthy: "server",
+			falsy: "browser"
+		} : {
+			truthy: "browser",
+			falsy: "server"
+		};
+		return equal ? { truthy: "browser" } : { falsy: "browser" };
+	}
+	return {};
+}
+/**
+* Source ranges only the browser reaches: the arm of an `if`/ternary its browser guard selects, the
+* right side of `browser && x` or `!browser || x`, and the statements after a terminating early return
+* the server always takes (`if (!browser) return;`) in their block. A top-level `const` derived from a
+* guard (`const serverOnly = !browser`) carries its own polarity.
+*/
+function browserOnlyRanges(program, envGuards) {
+	const guards = new Map([...envGuards].map((name) => [name, {
+		truthy: "browser",
+		falsy: "server"
+	}]));
+	const bound = collectProgramBindings(program);
+	for (const name of envGuards) bound.delete(name);
+	for (const stmt of program.body ?? []) {
+		const decl = unwrapExport(stmt);
+		if (decl?.type !== "VariableDeclaration" || decl.kind !== "const") continue;
+		for (const d of decl.declarations ?? []) {
+			const implied = d?.id?.type === "Identifier" && d.init ? guardImplies(d.init, guards, bound) : {};
+			if (implied.truthy || implied.falsy) guards.set(d.id.name, implied);
+		}
+	}
+	for (const name of guards.keys()) bound.delete(name);
+	const out = [];
+	const push = (n) => n && out.push([n.start, n.end]);
+	walkScoped(program, (n, shadowed) => {
+		const implies = (test) => guardImplies(test, guards, shadowed);
+		if (n.type === "IfStatement" || n.type === "ConditionalExpression") {
+			const implied = implies(n.test);
+			if (implied.truthy === "browser") push(n.consequent);
+			if (implied.falsy === "browser") push(n.alternate);
+		} else if (n.type === "LogicalExpression" && (n.operator === "&&" || n.operator === "||")) {
+			if (implies(n.left)[n.operator === "&&" ? "truthy" : "falsy"] === "browser") push(n.right);
+		} else if (n.type === "BlockStatement" || n.type === "Program") {
+			const body = n.body ?? [];
+			const at = body.findIndex((stmt) => stmt?.type === "IfStatement" && implies(stmt.test).falsy === "browser" && guardTerminates(stmt.consequent));
+			if (at >= 0 && at < body.length - 1) out.push([body[at + 1].start, body[body.length - 1].end]);
+		}
+	}, bound);
+	return out;
+}
 /**
 * Browser-global reads in code that executes when `program` (or a passed function body)
 * is evaluated (correctness/server-browser-global, correctness/instance-browser-global). Position-aware — only read positions match: never a
@@ -3940,6 +4200,12 @@ function collectBrowserGlobalRefs(program, source, extra) {
 		if (EVAL_SCOPE_BOUNDARIES.has(n.type)) return;
 		if ((n.type === "IfStatement" || n.type === "ConditionalExpression") && isBrowserGuardTest(n.test, guards)) return;
 		if (n.type === "LogicalExpression" && (n.operator === "&&" ? isBrowserGuardTest(n.left, guards) : n.left?.type === "UnaryExpression" && n.left.operator === "!" && isBrowserGuardTest(n.left.argument, guards))) return;
+		const missing = n.type === "LogicalExpression" && n.operator === "||" ? missingGlobalOf(n.left) : void 0;
+		if (missing && !bound.has(missing) && !shadowed.has(missing)) {
+			visit(n.left, shadowed);
+			if (!DOM_ONLY_GLOBALS.has(missing)) visit(n.right, /* @__PURE__ */ new Set([...shadowed, missing]));
+			return;
+		}
 		const introduced = scopeIntroducedNames(n);
 		const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
 		switch (n.type) {
@@ -4034,6 +4300,11 @@ const HANDLER_NAMES = /* @__PURE__ */ new Set([
 	"OPTIONS",
 	"fallback"
 ]);
+/** Whether `arg` can be a store updater: a function literal, or a function this module declares. */
+function isUpdaterArgument(arg, localFunctions) {
+	const e = arg ? unwrapTs(arg) : void 0;
+	return isFunctionNode(e) || e?.type === "Identifier" && localFunctions.has(e.name);
+}
 function isFunctionNode(n) {
 	return n?.type === "FunctionDeclaration" || n?.type === "FunctionExpression" || n?.type === "ArrowFunctionExpression";
 }
@@ -4135,7 +4406,7 @@ function collectStartupFunctions(program) {
 }
 /**
 * The `export const ssr = false` / `export const csr = false` opt-out, when
-* present: inline form (`satisfies`/`as` unwrapped) or same-file alias export
+* present (`= dev` too): inline form (`satisfies`/`as` unwrapped) or same-file alias export
 * (`const ssr = false; export { ssr };`). Returns the declaration's line in the
 * WRAPPED source (the caller applies the −1 shift). An `ssr = false` file never
 * runs on the server — correctness/server-browser-global skips its browser-global scan, and seo/ssr-disabled
@@ -4143,10 +4414,27 @@ function collectStartupFunctions(program) {
 * performance/load-waterfall exempts it (see `csrDisabled` on `KitModuleFacts`).
 */
 function findFalseOptOut(program, source, name) {
+	const dev = collectNamedImportAliases(program, "$app/environment", DEV_NAMES);
 	let hit;
 	forEachNamedExport(program, (exported, value, anchor) => {
-		if (exported !== name || value?.type !== "Literal" || value.value !== false) return void 0;
-		hit = { line: lineOf(source, anchor.start) };
+		const literal = value?.type === "Literal" && value.value === false;
+		if (exported !== name || !(literal || value?.type === "Identifier" && dev.has(value.name))) return void 0;
+		hit = {
+			line: lineOf(source, anchor.start),
+			literal
+		};
+		return true;
+	});
+	return hit;
+}
+const DEV_NAMES = /* @__PURE__ */ new Set(["dev"]);
+const BUILDING_NAMES = /* @__PURE__ */ new Set(["building"]);
+/** Whether the module exports `name` as the literal `true` (inline or same-file alias export). */
+function exportsTrue(program, name) {
+	let hit = false;
+	forEachNamedExport(program, (exported, value) => {
+		if (exported !== name) return void 0;
+		hit = value?.type === "Literal" && value.value === true;
 		return true;
 	});
 	return hit;
@@ -4197,8 +4485,18 @@ const MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"add",
 	"set"
 ]);
+const ITERATING_METHODS = /* @__PURE__ */ new Set([
+	"forEach",
+	"map",
+	"flatMap",
+	"filter",
+	"some",
+	"every",
+	"reduce"
+]);
 const REDIRECT_NAMES = /* @__PURE__ */ new Set(["redirect"]);
 const EXIT_NAMES = /* @__PURE__ */ new Set(["redirect", "error"]);
+const ERROR_NAMES = /* @__PURE__ */ new Set(["error"]);
 /**
 * Root-relative `redirect(status, '/…')` targets (correctness/base-path-navigation). Argument 1
 * is the location (argument 0 is the status). Only a plain string literal counts, which
@@ -4218,6 +4516,116 @@ function collectRedirectCalls(node, locals, out = []) {
 	}
 	return out;
 }
+/**
+* The string literals a `transformPageChunk` option replaces in the page HTML (`html.replace(TOKEN, …)`,
+* `.replaceAll`), wherever the file passes one to `resolve`, a same-file `const` holding the string
+* included. A token the hook builds at run time is not read.
+*/
+function pageChunkTokens(program) {
+	const consts = /* @__PURE__ */ new Map();
+	for (const stmt of program.body ?? []) {
+		const decl = stmt?.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+		if (decl?.type !== "VariableDeclaration" || decl.kind !== "const") continue;
+		for (const d of decl.declarations ?? []) {
+			const init = unwrapTs(d.init);
+			if (d.id?.type === "Identifier" && init?.type === "Literal" && typeof init.value === "string") consts.set(d.id.name, init.value);
+		}
+	}
+	const out = /* @__PURE__ */ new Set();
+	const visit = (n, inChunk) => {
+		if (Array.isArray(n)) return n.forEach((c) => visit(c, inChunk));
+		if (!n || typeof n !== "object" || typeof n.type !== "string") return;
+		const chunk = inChunk || n.type === "Property" && !n.computed && n.key?.type === "Identifier" && n.key.name === "transformPageChunk";
+		if (chunk && n.type === "CallExpression" && n.callee?.type === "MemberExpression" && !n.callee.computed) {
+			const method = n.callee.property?.name;
+			const arg = unwrapTs(n.arguments?.[0]);
+			const token = arg?.type === "Literal" && typeof arg.value === "string" ? arg.value : arg?.type === "Identifier" ? consts.get(arg.name) : void 0;
+			if ((method === "replace" || method === "replaceAll") && token) out.add(token);
+		}
+		for (const key of Object.keys(n)) if (!WALK_IGNORED_KEYS.has(key)) visit(n[key], chunk);
+	};
+	visit(program, false);
+	return [...out];
+}
+/** Whether `node` calls `name` outside nested functions. */
+function callsOutsideFunctions(node, name) {
+	if (Array.isArray(node)) return node.some((n) => callsOutsideFunctions(n, name));
+	if (!node || typeof node !== "object" || typeof node.type !== "string") return false;
+	if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === name) return true;
+	return Object.keys(node).some((key) => !WALK_IGNORED_KEYS.has(key) && callsOutsideFunctions(node[key], name));
+}
+/**
+* The request paths the exported `handle` answers on every request, before calling `resolve`: an `if` on
+* the path alone (`pathname === '/x'`, `pathname.startsWith('/x')`, or an `||` of those, with `pathname`
+* read from the `event` parameter, directly or through a `const`) whose body returns or throws, among the
+* statements before the first one that calls `resolve`. A test that also reads anything else, a `sequence(…)`
+* handle and a guard in another function are not read.
+*/
+function handleAnsweredPaths(program, exits) {
+	let handle;
+	forEachNamedExport(program, (name, value) => {
+		if (name === "handle" && isFunctionNode(value)) handle = value;
+		return handle !== void 0;
+	});
+	const param = handle?.params?.[0];
+	if (handle?.body?.type !== "BlockStatement" || param?.type !== "ObjectPattern") return [];
+	const local = (key) => {
+		const p = param.properties?.find((q) => q.type === "Property" && q.key?.type === "Identifier" && q.key.name === key);
+		return p?.value?.type === "Identifier" ? p.value.name : void 0;
+	};
+	const event = local("event");
+	const resolve = local("resolve");
+	if (!event || !resolve) return [];
+	const isUrl = (n) => n?.type === "MemberExpression" && !n.computed && n.property?.name === "url" && n.object?.type === "Identifier" && n.object.name === event;
+	const aliases = /* @__PURE__ */ new Set();
+	const isPath = (n) => {
+		const e = unwrapTs(n);
+		if (e?.type === "Identifier") return aliases.has(e.name);
+		return e?.type === "MemberExpression" && !e.computed && e.property?.name === "pathname" && isUrl(e.object);
+	};
+	const literal = (n) => n?.type === "Literal" && typeof n.value === "string" ? n.value : void 0;
+	const conds = (t) => {
+		if (t?.type === "LogicalExpression" && t.operator === "||") {
+			const l = conds(t.left);
+			const r = conds(t.right);
+			return l && r ? [...l, ...r] : void 0;
+		}
+		if (t?.type === "BinaryExpression" && (t.operator === "===" || t.operator === "==")) {
+			const v = isPath(t.left) ? literal(t.right) : isPath(t.right) ? literal(t.left) : void 0;
+			return v === void 0 ? void 0 : [{
+				op: "eq",
+				v
+			}];
+		}
+		const callee = t?.type === "CallExpression" ? t.callee : void 0;
+		const v = literal(t?.arguments?.[0]);
+		return callee?.type === "MemberExpression" && callee.property?.name === "startsWith" && isPath(callee.object) && v !== void 0 ? [{
+			op: "starts",
+			v
+		}] : void 0;
+	};
+	const exitsAlways = (s) => {
+		if (s?.type === "BlockStatement") return s.body.length > 0 && exitsAlways(s.body[s.body.length - 1]);
+		if (s?.type === "ReturnStatement" || s?.type === "ThrowStatement") return true;
+		const call = s?.type === "ExpressionStatement" ? unwrapTs(s.expression) : void 0;
+		return call?.type === "CallExpression" && call.callee?.type === "Identifier" && exits.has(call.callee.name);
+	};
+	const out = [];
+	for (const stmt of handle.body.body) {
+		if (callsOutsideFunctions(stmt, resolve)) break;
+		if (stmt.type === "VariableDeclaration" && stmt.kind === "const") for (const d of stmt.declarations ?? []) {
+			if (d.id?.type === "Identifier" && isPath(d.init)) aliases.add(d.id.name);
+			if (d.id?.type === "ObjectPattern" && isUrl(unwrapTs(d.init))) {
+				const p = d.id.properties?.find((q) => q.type === "Property" && q.key?.name === "pathname");
+				if (p?.value?.type === "Identifier") aliases.add(p.value.name);
+			}
+		}
+		if (stmt.type !== "IfStatement" || !exitsAlways(stmt.consequent)) continue;
+		const c = conds(stmt.test);
+		if (c) out.push(...c);
+	}
+	return out;
+}
 /** Whether `node` holds a `return` outside nested functions. */
 function containsReturn(node) {
 	if (Array.isArray(node)) return node.some(containsReturn);
@@ -4232,9 +4640,16 @@ function containsReturn(node) {
 * of the same file that itself always redirects. A redirect under an `if` without an `else`, in a
 * loop, or in a function declared inside `load` does not count.
 */
-function loadNeverRenders(program, locals) {
+function loadNeverRenders(program, locals, building = /* @__PURE__ */ new Set()) {
 	const load = locals.size > 0 ? findLoadFunction(program) : void 0;
-	if (!load?.body) return false;
+	return !!load?.body && alwaysExits(program, load, locals, building);
+}
+/**
+* Whether `fn`, a function of `program`, redirects or errors on every call (see `loadNeverRenders`).
+* `building` holds the names `building` from `$app/environment` is imported as: an `if` on one of them
+* is read with the test false, as it is on every request.
+*/
+function alwaysExits(program, fn, locals, building = /* @__PURE__ */ new Set()) {
 	const topLevel = collectTopLevelBindings(program);
 	const fnRedirects = (fn, seen, observed) => {
 		const shadow = /* @__PURE__ */ new Set();
@@ -4276,15 +4691,183 @@ function loadNeverRenders(program, locals) {
 		}
 		return false;
 	};
+	const plainReturn = (node, shadow, frame) => {
+		if (Array.isArray(node)) return node.some((n) => plainReturn(n, shadow, frame));
+		if (!node || typeof node !== "object" || typeof node.type !== "string" || isFunctionNode(node)) return false;
+		if (node.type === "ReturnStatement") return !isRedirect(node.argument, shadow, frame, frame.observed);
+		const scope = node.type === "BlockStatement" ? within(node.body, shadow) : shadow;
+		return Object.keys(node).some((key) => !WALK_IGNORED_KEYS.has(key) && plainReturn(node[key], scope, frame));
+	};
 	const always = (body, outer, rethrow, frame) => {
 		const shadow = within(body, outer);
-		for (const stmt of body ?? []) {
+		for (let stmt of body ?? []) {
+			const test = stmt?.type === "IfStatement" ? unwrapTs(stmt.test) : void 0;
+			if (test?.type === "Identifier" && building.has(test.name) && !shadow.has(test.name)) {
+				if (!stmt.alternate) continue;
+				stmt = stmt.alternate;
+			}
 			if (redirects(stmt, shadow, rethrow, frame)) return true;
-			if (containsReturn(stmt)) return false;
+			if (plainReturn(stmt, shadow, frame)) return false;
 		}
 		return false;
 	};
-	return fnRedirects(load, /* @__PURE__ */ new Set(), true);
+	return fnRedirects(fn, /* @__PURE__ */ new Set(), true);
+}
+/**
+* The binding a load's leading flag guard reads: a top-level `if (!FLAG) <exit>` (or `!NS.FLAG`) before
+* any `return`, where `FLAG` is imported from a repo-local module. When that export is the literal
+* `false`, every request takes the exit; `collectKitModuleFacts` reads the module to decide.
+*/
+function leadingFlagGuard(program, exits, imported) {
+	const load = exits.size > 0 ? findLoadFunction(program) : void 0;
+	if (load?.body?.type !== "BlockStatement") return void 0;
+	const local = /* @__PURE__ */ new Set();
+	for (const param of load.params ?? []) addBoundNames(param, local);
+	for (const stmt of load.body.body) if (stmt?.type === "VariableDeclaration") for (const d of stmt.declarations ?? []) addBoundNames(d?.id, local);
+	else if ((stmt?.type === "FunctionDeclaration" || stmt?.type === "ClassDeclaration") && stmt.id) local.add(stmt.id.name);
+	const exitCall = (e) => {
+		const x = unwrapTs(e);
+		return x?.type === "CallExpression" && x.callee?.type === "Identifier" && exits.has(x.callee.name) && !local.has(x.callee.name);
+	};
+	const exitsFirst = (stmt) => {
+		if (stmt?.type === "BlockStatement") {
+			for (const inner of stmt.body) {
+				if (exitsFirst(inner)) return true;
+				if (containsReturn(inner)) return false;
+			}
+			return false;
+		}
+		return stmt?.type === "ExpressionStatement" && exitCall(stmt.expression) || (stmt?.type === "ThrowStatement" || stmt?.type === "ReturnStatement") && exitCall(stmt.argument);
+	};
+	for (const stmt of load.body.body) {
+		const test = stmt?.type === "IfStatement" && exitsFirst(stmt.consequent) ? unwrapTs(stmt.test) : void 0;
+		if (test?.type === "UnaryExpression" && test.operator === "!") {
+			const arg = unwrapTs(test.argument);
+			const root = arg?.type === "MemberExpression" && !arg.computed ? unwrapTs(arg.object) : arg;
+			const member = arg !== root && arg.property?.type === "Identifier" ? arg.property.name : void 0;
+			const from = root?.type === "Identifier" && !local.has(root.name) && (arg === root || member) ? imported(root.name) : void 0;
+			if (from) return {
+				...from,
+				...member ? { member } : {}
+			};
+		}
+		if (containsReturn(stmt)) return void 0;
+	}
+}
+/** The imported function `export const load = factory(…)` calls, for `collectKitModuleFacts` to read. */
+function loadFactory(program, imported) {
+	let call;
+	forEachNamedExport(program, (name, value) => {
+		if (name !== "load") return void 0;
+		call = unwrapTs(value);
+		return true;
+	});
+	return call?.type === "CallExpression" && call.callee?.type === "Identifier" ? imported(call.callee.name) : void 0;
+}
+/**
+* The exported functions of a module that return a function which redirects or errors on every call
+* (`createRedirect = (to) => () => redirect(307, to)`), read like a `load` that does.
+*/
+function parseExitFactoryExports(source, filename) {
+	const { program } = parseModuleProgram(source, filename);
+	const exits = collectNamedImportAliases(program, "@sveltejs/kit", EXIT_NAMES);
+	const names = /* @__PURE__ */ new Set();
+	if (exits.size === 0) return names;
+	forEachNamedExport(program, (name, value) => {
+		if (!isFunctionNode(value)) return void 0;
+		const first = (value.body?.type === "BlockStatement" ? value.body.body : [{
+			type: "ReturnStatement",
+			argument: value.body
+		}]).find((stmt) => containsReturn(stmt));
+		const returned = first?.type === "ReturnStatement" ? first.argument : void 0;
+		if (isFunctionNode(returned) && alwaysExits(program, returned, exits)) names.add(name);
+	});
+	return names;
+}
+/** The exports of a module that are the literal `false`, as `NAME` or `NAME.member` (an object literal's own property). */
+function parseFalseExports(source, filename) {
+	return collectFalseExports(parseModuleProgram(source, filename).program);
+}
+/** `parseFalseExports` over a parsed module. */
+function collectFalseExports(program) {
+	const names = /* @__PURE__ */ new Set();
+	for (const stmt of program?.body ?? []) {
+		if (stmt?.type !== "ExportNamedDeclaration" || stmt.declaration?.type !== "VariableDeclaration") continue;
+		if (stmt.declaration.kind !== "const") continue;
+		for (const d of stmt.declaration.declarations ?? []) {
+			const init = unwrapTs(d?.init);
+			if (d?.id?.type !== "Identifier") continue;
+			if (init?.type === "Literal" && init.value === false) names.add(d.id.name);
+			if (init?.type === "ObjectExpression") {
+				const members = /* @__PURE__ */ new Map();
+				for (const p of init.properties ?? []) {
+					const v = unwrapTs(p?.value);
+					if (p?.type !== "Property" || p.computed || p.key?.type !== "Identifier") members.clear();
+					else members.set(p.key.name, v?.type === "Literal" && v.value === false);
+				}
+				for (const [key, isFalse] of members) if (isFalse) names.add(`${d.id.name}.${key}`);
+			}
+		}
+	}
+	return names;
+}
+/**
+* Whether the exported `load` sends a request without a session away before rendering: a top-level
+* `if` whose test is only negated reads of the request's `locals` (`!locals.user`,
+* `!(await locals.auth())`, or a `const` taken from one earlier in the body) and whose branch
+* redirects or errors 401/403. A test that also reads anything else — the URL, params — gates only
+* some requests and does not count; neither does a gate after a `return`.
+*/
+function loadGatesOnLocals(program) {
+	const redirects = collectNamedImportAliases(program, "@sveltejs/kit", REDIRECT_NAMES);
+	const errors = collectNamedImportAliases(program, "@sveltejs/kit", ERROR_NAMES);
+	const load = redirects.size + errors.size > 0 ? findLoadFunction(program) : void 0;
+	if (load?.body?.type !== "BlockStatement") return false;
+	const param = load.params?.[0];
+	const event = param?.type === "Identifier" ? param.name : void 0;
+	const derived = /* @__PURE__ */ new Set();
+	if (param?.type === "ObjectPattern") {
+		for (const p of param.properties ?? []) if (p?.type === "Property" && (p.key?.name ?? p.key?.value) === "locals") addBoundNames(p.value, derived);
+	}
+	const fromLocals = (expr) => {
+		let cur = unwrapTs(expr);
+		let prev;
+		for (;;) if (cur?.type === "AwaitExpression" || cur?.type === "ChainExpression") cur = unwrapTs(cur.argument ?? cur.expression);
+		else if (cur?.type === "CallExpression" && (cur.arguments ?? []).length === 0) cur = unwrapTs(cur.callee);
+		else if (cur?.type === "MemberExpression" && !cur.computed) [prev, cur] = [cur, unwrapTs(cur.object)];
+		else break;
+		if (cur?.type !== "Identifier") return false;
+		return derived.has(cur.name) || cur.name === event && prev?.computed === false && prev.property?.name === "locals";
+	};
+	const negated = (test) => {
+		const t = unwrapTs(test);
+		if (t?.type === "LogicalExpression") return t.operator === "||" && negated(t.left) && negated(t.right);
+		return t?.type === "UnaryExpression" && t.operator === "!" && fromLocals(t.argument);
+	};
+	const exitCall = (expr) => {
+		const e = unwrapTs(expr);
+		if (e?.type !== "CallExpression" || e.callee?.type !== "Identifier") return false;
+		if (redirects.has(e.callee.name)) return true;
+		if (!errors.has(e.callee.name)) return false;
+		const status = e.arguments?.[0];
+		return status?.type === "Literal" && (status.value === 401 || status.value === 403);
+	};
+	const exitsNow = (stmt) => {
+		if (stmt?.type !== "BlockStatement") return stmt?.type === "ExpressionStatement" && exitCall(stmt.expression) || (stmt?.type === "ThrowStatement" || stmt?.type === "ReturnStatement") && exitCall(stmt.argument);
+		for (const inner of stmt.body) {
+			if (exitsNow(inner)) return true;
+			if (containsReturn(inner)) return false;
+		}
+		return false;
+	};
+	for (const stmt of load.body.body) {
+		if (stmt?.type === "IfStatement" && negated(stmt.test) && exitsNow(stmt.consequent)) return true;
+		if (containsReturn(stmt)) return false;
+		if (stmt?.type === "VariableDeclaration" && stmt.kind === "const") {
+			for (const d of stmt.declarations ?? []) if (d?.init && fromLocals(d.init)) addBoundNames(d.id, derived);
+		}
+	}
+	return false;
 }
 /**
 * Whether `await`'s argument is a `parent()` / `<x>.parent()` call (Kit's parent-load
@@ -4306,6 +4889,7 @@ const BODY_METHODS = /* @__PURE__ */ new Set([
 	"formData",
 	"bytes"
 ]);
+const PROMISE_COMBINATORS = /* @__PURE__ */ new Set(["all", "allSettled"]);
 /**
 * Whether `await`'s argument is a response-body read (`res.json()`, `res.text()`, …):
 * parsing an already-received body costs no extra round trip, so it is not a
@@ -4314,9 +4898,12 @@ const BODY_METHODS = /* @__PURE__ */ new Set([
 */
 function isBodyParseCall(arg) {
 	const e = unwrapTs(arg);
-	if (e?.type !== "CallExpression" || e.arguments?.length) return false;
+	if (e?.type !== "CallExpression") return false;
 	const callee = e.callee;
-	return callee?.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && BODY_METHODS.has(callee.property.name);
+	if (callee?.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") return false;
+	if (BODY_METHODS.has(callee.property.name)) return !e.arguments?.length;
+	const list = e.arguments?.length === 1 ? unwrapTs(e.arguments[0]) : void 0;
+	return callee.object.type === "Identifier" && callee.object.name === "Promise" && PROMISE_COMBINATORS.has(callee.property.name) && list?.type === "ArrayExpression" && list.elements.length > 0 && list.elements.every((el) => el && isBodyParseCall(el));
 }
 const WORK_STARTING = /* @__PURE__ */ new Set([
 	"CallExpression",
@@ -4413,6 +5000,19 @@ function collectLoadWaterfalls(program, wrapped) {
 	};
 	const line = (start) => Math.max(0, lineOf(wrapped, start) - 1);
 	const tainted = /* @__PURE__ */ new Set();
+	const ownBindings = /* @__PURE__ */ new Set();
+	const collectOwn = (body) => {
+		for (const stmt of body ?? []) {
+			if (stmt?.type === "TryStatement") collectOwn(stmt.block?.body);
+			if (stmt?.type !== "VariableDeclaration") continue;
+			for (const d of stmt.declarations ?? []) {
+				let init = unwrapTs(d?.init);
+				if (init?.type === "AwaitExpression") init = unwrapTs(init.argument);
+				if (init?.type === "CallExpression" || init?.type === "NewExpression") addBoundNames(d?.id, ownBindings);
+			}
+		}
+	};
+	collectOwn(load.body.body);
 	const syncTainted = /* @__PURE__ */ new Set();
 	let sawAwaitSite = false;
 	const taintTarget = (target, rhs) => {
@@ -4435,6 +5035,26 @@ function collectLoadWaterfalls(program, wrapped) {
 		const root = rootObjectName(callee);
 		if (root) tainted.add(root);
 	};
+	const taintLoopFill = (call) => {
+		const callee = unwrapTs(call?.callee);
+		if (call?.type !== "CallExpression" || callee?.type !== "MemberExpression" || callee.computed) return;
+		if (!ITERATING_METHODS.has(callee.property?.name) || !refsTainted(callee.object, tainted)) return;
+		const fill = (node) => {
+			if (Array.isArray(node)) return node.forEach(fill);
+			if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+			if (isFunctionNode(node)) return;
+			const c = node.type === "CallExpression" ? unwrapTs(node.callee) : void 0;
+			if (c?.type === "MemberExpression" && !c.computed && MUTATING_METHODS.has(c.property?.name)) {
+				const root = rootObjectName(c);
+				if (root) tainted.add(root);
+			}
+			if (c?.type === "MemberExpression" && !c.computed && ITERATING_METHODS.has(c.property?.name)) {
+				for (const arg of node.arguments ?? []) if (isFunctionNode(arg)) fill(arg.body);
+			}
+			for (const key of Object.keys(node)) if (!WALK_IGNORED_KEYS.has(key)) fill(node[key]);
+		};
+		for (const arg of call.arguments ?? []) if (isFunctionNode(arg)) fill(arg.body);
+	};
 	const taintOnly = (node) => {
 		if (Array.isArray(node)) {
 			for (const child of node) taintOnly(child);
@@ -4443,13 +5063,18 @@ function collectLoadWaterfalls(program, wrapped) {
 		if (!node || typeof node !== "object" || typeof node.type !== "string") return;
 		if (isFunctionNode(node)) return;
 		if (node.type === "AssignmentExpression") taintTarget(node.left, node.right);
-		else if (node.type === "CallExpression") taintMutation(node);
-		else if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && refsTainted(node.right, tainted)) {
+		else if (node.type === "CallExpression") {
+			taintMutation(node);
+			taintLoopFill(node);
+		} else if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && refsTainted(node.right, tainted)) {
 			const names = /* @__PURE__ */ new Set();
 			addBoundNames(node.left?.type === "VariableDeclaration" ? node.left.declarations?.[0]?.id : node.left, names);
 			for (const name of names) tainted.add(name);
 		} else if (node.type === "VariableDeclaration") {
-			for (const d of node.declarations ?? []) if (d?.id && d.init) taintTarget(d.id, d.init);
+			for (const d of node.declarations ?? []) if (d?.id && d.init) {
+				taintTarget(d.id, d.init);
+				taintLoopFill(unwrapTs(d.init));
+			}
 		}
 		for (const key of Object.keys(node)) {
 			if (WALK_IGNORED_KEYS.has(key)) continue;
@@ -4483,11 +5108,21 @@ function collectLoadWaterfalls(program, wrapped) {
 					sawAwaitSite = true;
 				}
 				if (stmt.type === "VariableDeclaration") {
-					for (const d of stmt.declarations ?? []) if (d?.id && d.init) taintTarget(d.id, d.init);
+					for (const d of stmt.declarations ?? []) if (d?.id && d.init) {
+						taintTarget(d.id, d.init);
+						taintLoopFill(unwrapTs(d.init));
+					}
 				} else if (stmt.type === "ExpressionStatement") {
 					const expr = unwrapTs(stmt.expression);
 					if (expr?.type === "AssignmentExpression") taintTarget(expr.left, expr.right);
-					else taintMutation(expr);
+					else {
+						taintMutation(expr);
+						taintLoopFill(expr);
+					}
+					const call = expr?.type === "AwaitExpression" ? unwrapTs(expr.argument) : void 0;
+					const callee = call?.type === "CallExpression" ? unwrapTs(call.callee) : void 0;
+					const owner = callee?.type === "MemberExpression" && !callee.computed ? unwrapTs(callee.object) : void 0;
+					if (owner?.type === "Identifier" && ownBindings.has(owner.name)) tainted.add(owner.name);
 				}
 			} else taintOnly(stmt);
 		}
@@ -4584,7 +5219,7 @@ function aliasMatches(entry, spec) {
 */
 function resolveRepoLocalPath(spec, importerFile, aliases = DEFAULT_KIT_ALIASES) {
 	let path;
-	if (spec.startsWith("./") || spec.startsWith("../")) path = `${importerFile.split("/").slice(0, -1).join("/")}/${spec}`;
+	if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../")) path = `${importerFile.split("/").slice(0, -1).join("/")}/${spec}`;
 	else {
 		const entry = aliases.find((a) => aliasMatches(a, spec));
 		if (entry?.replacement == null) return void 0;
@@ -4650,13 +5285,9 @@ function libServerRoot(aliases) {
 * risks a false positive in this default-on security rule, and staying silent only costs a
 * missed finding.
 */
-/** The resolved repo path when `spec` lands on, or under, the `$lib` server root; else undefined. */
-function serverRootRelativePath(spec, importerFile, aliases) {
-	const serverRoot = libServerRoot(aliases);
-	if (serverRoot === void 0) return void 0;
-	const path = resolveRepoLocalPath(spec, importerFile, aliases);
-	if (path === void 0) return void 0;
-	return path === serverRoot || path.startsWith(`${serverRoot}/`) ? path : void 0;
+/** The resolved repo path of a repo-local `spec`, or undefined when it is a package or the `$lib` root is opaque. */
+function localModulePath(spec, importerFile, aliases) {
+	return libServerRoot(aliases) === void 0 ? void 0 : resolveRepoLocalPath(spec, importerFile, aliases);
 }
 function isLocalStateSpecifier(spec, importerFile, aliases) {
 	const serverRoot = libServerRoot(aliases);
@@ -4672,23 +5303,60 @@ const IN_MEMORY_CTORS = /* @__PURE__ */ new Set([
 	"WeakMap",
 	"WeakSet"
 ]);
+const isContainerCtor = (n) => n?.type === "NewExpression" && n.callee?.type === "Identifier" && IN_MEMORY_CTORS.has(n.callee.name);
 /**
 * Whether an initializer positively identifies an in-memory container. An object literal with a
 * spread is a composite of values this parse cannot see — typically a facade over clients and
 * imported modules (`{ ...prismaModels, ...handlers }`) — so it counts only when one of its own
-* properties is itself a container.
+* properties is itself a container. One whose properties are all functions (`{ get, set }` of the
+* module's own functions) holds no data: `.set()` on it calls its own method.
 */
-function isInMemoryInit(init) {
+function isInMemoryInit(init, fns = /* @__PURE__ */ new Set()) {
 	if (!init) return false;
 	if (init.type === "ArrayExpression") return true;
 	if (init.type === "ObjectExpression") {
 		const props = init.properties ?? [];
+		const isFn = (p) => p?.type === "Property" && (p.method || p.value?.type === "FunctionExpression" || p.value?.type === "ArrowFunctionExpression" || p.value?.type === "Identifier" && fns.has(p.value.name));
+		if (props.length > 0 && props.every(isFn)) return false;
 		if (!props.some((p) => p?.type === "SpreadElement")) return true;
-		return props.some((p) => p?.type === "Property" && isInMemoryInit(p.value));
+		return props.some((p) => p?.type === "Property" && isInMemoryInit(p.value, fns));
 	}
 	return init.type === "NewExpression" && init.callee?.type === "Identifier" && IN_MEMORY_CTORS.has(init.callee.name);
 }
 /**
+* The exported bindings of a module that are a persistence or API client: `new C()` of a class imported
+* from an installed package, or of a class this module declares that neither extends another class nor
+* keeps a `Map`/`Set`/`WeakMap`/`WeakSet` field; or a call into an installed package (`drizzle(…)`,
+* `createClient(…)`). A write through one of them reaches a database or service, not module state.
+*/
+function parseClientExports(source, filename, aliases) {
+	const names = /* @__PURE__ */ new Set();
+	const { program } = parseModuleProgram(source, filename);
+	const fromPackage = /* @__PURE__ */ new Set();
+	for (const stmt of program?.body ?? []) {
+		const src = stmt?.type === "ImportDeclaration" ? String(stmt.source?.value ?? "") : "";
+		if (!(!src || /^[./$~#]|^@\//.test(src) || resolveRepoLocalPath(src, filename, aliases) !== void 0) && !/^svelte|store/i.test(src)) for (const sp of stmt.specifiers ?? []) fromPackage.add(sp.local.name);
+	}
+	const plainClasses = /* @__PURE__ */ new Set();
+	for (const stmt of program?.body ?? []) {
+		const decl = unwrapExport(stmt);
+		if (decl?.type !== "ClassDeclaration" || !decl.id || decl.superClass) continue;
+		if (!(decl.body?.body ?? []).some((m) => isContainerCtor(m?.value) || m?.kind === "constructor" && m.value?.body?.body?.some((st) => st?.type === "ExpressionStatement" && isContainerCtor(st.expression?.right)))) plainClasses.add(decl.id.name);
+	}
+	for (const stmt of program?.body ?? []) {
+		if (stmt?.type !== "ExportNamedDeclaration" || stmt.declaration?.type !== "VariableDeclaration") continue;
+		for (const d of stmt.declaration.declarations ?? []) {
+			let init = unwrapTs(d?.init);
+			if (init?.type === "AwaitExpression") init = unwrapTs(init.argument);
+			if (d?.id?.type !== "Identifier") continue;
+			const ctor = init?.type === "NewExpression" && init.callee?.type === "Identifier" ? init.callee.name : void 0;
+			if (ctor !== void 0 && (fromPackage.has(ctor) || plainClasses.has(ctor))) names.add(d.id.name);
+			if (init?.type === "CallExpression" && fromPackage.has(rootObjectName(init.callee) ?? "")) names.add(d.id.name);
+		}
+	}
+	return names;
+}
+/**
 * The exported bindings of a module that are initialized to an in-memory container — an object
 * or array literal (a spread literal only as `isInMemoryInit` allows), or `new Map`/`Set`/`WeakMap`/`WeakSet`. Used to arbitrate a `.set()` call on
 * an import from under the `$lib` server root, where the call shape alone cannot separate a
@@ -4702,11 +5370,16 @@ function isInMemoryInit(init) {
 function parseInMemoryExports(source, filename) {
 	const names = /* @__PURE__ */ new Set();
 	const { program } = parseModuleProgram(source, filename);
+	const fns = /* @__PURE__ */ new Set();
+	for (const stmt of program?.body ?? []) {
+		const decl = unwrapExport(stmt);
+		if (decl?.type === "FunctionDeclaration" && decl.id) fns.add(decl.id.name);
+	}
 	for (const stmt of program?.body ?? []) {
 		if (stmt?.type !== "ExportNamedDeclaration" || !stmt.declaration) continue;
 		const decl = stmt.declaration;
 		if (decl.type !== "VariableDeclaration") continue;
-		for (const d of decl.declarations ?? []) if (d?.id?.type === "Identifier" && isInMemoryInit(d.init)) names.add(d.id.name);
+		for (const d of decl.declarations ?? []) if (d?.id?.type === "Identifier" && isInMemoryInit(d.init, fns)) names.add(d.id.name);
 	}
 	return names;
 }
@@ -4722,6 +5395,7 @@ function parseKitModuleFacts(source, filename, aliases) {
 	const importedStateWrites = [];
 	const importedStateWritesOutsideHandlers = [];
 	const pendingServerStoreWrites = [];
+	const storeWriteTargets = [];
 	const runesModuleImports = [];
 	const lifecycleCalls = [];
 	const browserGlobalRefs = [];
@@ -4740,6 +5414,11 @@ function parseKitModuleFacts(source, filename, aliases) {
 	const importedSpecifiers = /* @__PURE__ */ new Map();
 	const importedNames = /* @__PURE__ */ new Map();
 	const namespaceImports = /* @__PURE__ */ new Set();
+	const localFunctions = /* @__PURE__ */ new Set();
+	walkEstree(program, (n) => {
+		if (n.type === "FunctionDeclaration" && n.id?.name) localFunctions.add(n.id.name);
+		if (n.type === "VariableDeclarator" && n.id?.type === "Identifier" && n.init && isFunctionNode(unwrapTs(n.init))) localFunctions.add(n.id.name);
+	});
 	for (const stmt of program.body ?? []) {
 		if (stmt?.type !== "ImportDeclaration" || stmt.importKind === "type") continue;
 		const spec = typeof stmt.source?.value === "string" ? stmt.source.value : "";
@@ -4771,7 +5450,7 @@ function parseKitModuleFacts(source, filename, aliases) {
 	const ssrOptOut = findFalseOptOut(program, wrapped, "ssr");
 	const csrOptOut = findFalseOptOut(program, wrapped, "csr");
 	const waterfalls = collectLoadWaterfalls(program, wrapped);
-	if (!ssrOptOut) {
+	if (!ssrOptOut?.literal) {
 		const shiftLine = (l) => Math.max(0, l - 1);
 		const browserImports = collectBrowserGuardImports(program);
 		const guards = /* @__PURE__ */ new Set([...browserImports, ...collectDerivedGuardBindings(program, browserImports)]);
@@ -4803,10 +5482,12 @@ function parseKitModuleFacts(source, filename, aliases) {
 			scanFn(fn, false);
 		}
 	}
+	const browserOnly = browserOnlyRanges(program, collectBrowserGuardImports(program));
+	const reachedOnlyByBrowser = (at) => browserOnly.some(([from, to]) => at >= from && at < to);
 	walkKit(program, handlerFns, startupFns, (n, shadowed, inFunction, inHandler, inStartup) => {
 		if (inFunction && !inStartup) {
 			const flagLet = (name) => {
-				if (name && !shadowed.has(name) && moduleLets.has(name)) moduleStateReassignments.push({
+				if (name && !shadowed.has(name) && moduleLets.has(name) && !reachedOnlyByBrowser(n.start)) moduleStateReassignments.push({
 					name,
 					line: line(n.start),
 					inHandler
@@ -4847,23 +5528,25 @@ function parseKitModuleFacts(source, filename, aliases) {
 		} else if (n.type === "CallExpression" && n.callee?.type === "MemberExpression") {
 			const method = n.callee.property?.type === "Identifier" ? n.callee.property.name : void 0;
 			const nsFunction = n.callee.object?.type === "Identifier" && namespaceImports.has(n.callee.object.name);
-			if ((method === "set" || method === "update") && !nsFunction) {
+			const updater = method !== "update" || isUpdaterArgument(n.arguments?.[0], localFunctions);
+			if ((method === "set" || method === "update") && !nsFunction && updater) {
 				const r = importedRoot(n.callee.object);
 				const spec = r ? importedSpecifiers.get(r) : void 0;
 				if (r && spec !== void 0) {
-					if (isLocalStateSpecifier(spec, filename, aliases)) write = {
+					const resolved = localModulePath(spec, filename, aliases);
+					const target = {
 						name: r,
-						via: "set-call"
+						imported: importedNames.get(r) ?? r,
+						resolved,
+						line: line(n.start)
 					};
-					else {
-						const resolved = serverRootRelativePath(spec, filename, aliases);
-						if (resolved !== void 0 && inHandler) pendingServerStoreWrites.push({
+					if (isLocalStateSpecifier(spec, filename, aliases)) {
+						write = {
 							name: r,
-							imported: importedNames.get(r) ?? r,
-							resolved,
-							line: line(n.start)
-						});
-					}
+							via: "set-call"
+						};
+						if (inHandler) storeWriteTargets.push(target);
+					} else if (resolved !== void 0 && inHandler) pendingServerStoreWrites.push(target);
 				}
 			}
 		} else if (n.type === "AssignmentExpression" && (n.left?.type === "ObjectPattern" || n.left?.type === "ArrayPattern")) {
@@ -4884,6 +5567,7 @@ function parseKitModuleFacts(source, filename, aliases) {
 			};
 			scanPatternTargets(n.left);
 		}
+		if (write && reachedOnlyByBrowser(n.start)) write = void 0;
 		if (write) {
 			if (inHandler) importedStateWrites.push({
 				...write,
@@ -4915,19 +5599,51 @@ function parseKitModuleFacts(source, filename, aliases) {
 			line: line(call.start)
 		});
 	}
+	const exitLocals = collectNamedImportAliases(program, "@sveltejs/kit", EXIT_NAMES);
+	const neverRenders = loadNeverRenders(program, exitLocals);
+	const building = collectNamedImportAliases(program, "$app/environment", BUILDING_NAMES);
+	const hooks = /(^|\/)hooks\.server\.(ts|js)$/.test(filename);
+	const answered = hooks ? handleAnsweredPaths(program, exitLocals) : [];
+	const chunkTokens = hooks ? pageChunkTokens(program) : [];
+	const flagGuard = leadingFlagGuard(program, exitLocals, (local) => {
+		const spec = namespaceImports.has(local) ? void 0 : importedSpecifiers.get(local);
+		const resolved = spec === void 0 ? void 0 : localModulePath(spec, filename, aliases);
+		return resolved === void 0 ? void 0 : {
+			resolved,
+			name: importedNames.get(local) ?? local
+		};
+	});
+	const factory = loadFactory(program, (local) => {
+		const spec = namespaceImports.has(local) ? void 0 : importedSpecifiers.get(local);
+		const resolved = spec === void 0 ? void 0 : localModulePath(spec, filename, aliases);
+		return resolved === void 0 ? void 0 : {
+			resolved,
+			name: importedNames.get(local) ?? local
+		};
+	});
 	return {
 		moduleStateReassignments: byLine(moduleStateReassignments),
 		importedStateWrites: byLine(importedStateWrites),
 		importedStateWritesOutsideHandlers: byLine(importedStateWritesOutsideHandlers),
 		pendingServerStoreWrites: byLine(pendingServerStoreWrites),
+		...storeWriteTargets.length > 0 ? { storeWriteTargets } : {},
 		runesModuleImports: byLine(runesModuleImports),
 		lifecycleCalls: byLine(lifecycleCalls),
 		browserGlobalRefs: byLine(browserGlobalRefs),
 		basePathLinks: byLine(basePathLinks),
 		...ssrOptOut ? { ssrDisabled: { line: Math.max(0, ssrOptOut.line - 1) } } : {},
 		...!ssrOptOut && exportsName(program, "ssr") ? { ssrEnabled: true } : {},
+		...!ssrOptOut && exportsTrue(program, "ssr") ? { ssrTrue: true } : {},
 		...csrOptOut ? { csrDisabled: { line: Math.max(0, csrOptOut.line - 1) } } : {},
-		...loadNeverRenders(program, collectNamedImportAliases(program, "@sveltejs/kit", EXIT_NAMES)) ? { loadNeverRenders: true } : {},
+		...!csrOptOut && exportsName(program, "csr") ? { csrEnabled: true } : {},
+		...neverRenders ? { loadNeverRenders: true } : {},
+		...!neverRenders && building.size > 0 && loadNeverRenders(program, exitLocals, building) ? { loadNeverRendersOutsideBuild: true } : {},
+		...exportsName(program, "prerender") ? { prerenderExported: true } : {},
+		...answered.length > 0 ? { answeredPaths: answered } : {},
+		...chunkTokens.length > 0 ? { pageChunkTokens: chunkTokens } : {},
+		...flagGuard ? { pendingFlagGuard: flagGuard } : {},
+		...factory ? { pendingLoadFactory: factory } : {},
+		...loadGatesOnLocals(program) ? { loadGated: true } : {},
 		...waterfalls.dependentLines.length > 0 || waterfalls.independentLines.length > 0 ? { loadWaterfalls: waterfalls } : {},
 		suppressions
 	};
@@ -6399,8 +7115,8 @@ const MESSAGE$1 = "Sequential dependent awaits in a universal load create a clie
 /**
 * performance/load-waterfall — dependent await chains in universal loads. Server loads are exempt:
 * a dependent chain cannot be parallelized, and on the server there is no better
-* placement to suggest. csr = false files are exempt too — without a client
-* runtime the universal load only runs during SSR.
+* placement to suggest. Loads on a route with `csr = false` (its own or a layout's) are exempt
+* too — without a client runtime the universal load only runs during SSR.
 */
 const performanceLoadWaterfall = kitModuleRule({
 	id: "performance/load-waterfall",
@@ -6415,7 +7131,7 @@ const performanceLoadWaterfall = kitModuleRule({
 		snippet: "// +page.server.ts — same chain, server-side hops\nexport async function load({ fetch }) {\n  const user = await fetch(`/api/user`).then((r) => r.json());\n  const posts = await fetch(`/api/posts/${user.id}`).then((r) => r.json());\n  return { user, posts };\n}",
 		lang: "ts"
 	},
-	applies: (m) => m.kind === "universal" && m.csrDisabled === void 0 && (m.loadWaterfalls?.dependentLines.length ?? 0) > 0,
+	applies: (m, ctx) => m.kind === "universal" && (m.loadWaterfalls?.dependentLines.length ?? 0) > 0 && !universalNeverCsr(m, ctx),
 	bad: (m) => m.loadWaterfalls.dependentLines.map((line) => ({
 		line,
 		message: MESSAGE$1
@@ -7088,7 +7804,7 @@ const a11yPatternTitle = componentRule({
 //#endregion
 //#region src/html-spec/generated.ts
 /*!
-* HTML spec data projected from @markuplint/html-spec@5.0.0 — https://github.com/markuplint/markuplint
+* HTML spec data projected from @markuplint/html-spec@5.0.1 — https://github.com/markuplint/markuplint
 *
 * MIT License
 *
@@ -8481,8 +9197,29 @@ function buildJsonReport(results, config, meta, ruleIds, examined, skipped) {
 	};
 }
 /** Render results as the documented JSON report string (design §7). */
-function formatJsonReport(results, config, meta, ruleIds, examined, skipped) {
-	return JSON.stringify(buildJsonReport(results, config, meta, ruleIds, examined, skipped), null, 2);
+function formatJsonReport(...args) {
+	return [...formatJsonReportChunks(...args)].join("");
+}
+/**
+* `formatJsonReport`'s text in pieces, one route at a time: a large prerendered site's report is
+* longer than the longest string V8 can hold.
+*/
+function* formatJsonReportChunks(results, config, meta, ruleIds, examined, skipped) {
+	const report = buildJsonReport(results, config, meta, ruleIds, examined, skipped);
+	const marker = JSON.stringify("\0routes");
+	const text = JSON.stringify({
+		...report,
+		routes: "\0routes"
+	}, null, 2);
+	const at = text.indexOf(marker);
+	yield text.slice(0, at);
+	if (report.routes.length === 0) yield "[]";
+	else {
+		yield "[\n";
+		for (const [i, route] of report.routes.entries()) yield `${i > 0 ? ",\n" : ""}    ${JSON.stringify(route, null, 2).replaceAll("\n", "\n    ")}`;
+		yield "\n  ]";
+	}
+	yield text.slice(at + marker.length);
 }
 //#endregion
 //#region src/reporter/sanitize.ts
@@ -8628,4 +9365,4 @@ function formatMarkdownReport(results, config, meta) {
 	return lines.join("\n");
 }
 //#endregion
-export { performanceMinifyDisabled as $, applyRuleSeverities as $n, correctnessOrphanLifecycle as $t, a11yAbbrTitle as A, seoImageAlt as An, defaultProject as Ar, walkEstree as At, a11yUseList as B, seoSitemapInRobots as Bn, parseSvelte as Bt, a11yDisallowedElement as C, foldOccurrences as Cn, effectiveSeverity as Cr, collectSvelteLifecycleImports as Ct, a11yDeprecatedElement as D, stripTextDirective as Dn, isPenalized as Dr, scopeIntroducedNames as Dt, a11yDeprecatedAttr as E, splitTokens as En, docsUrlFor as Er, rootObjectName as Et, isInteractiveContainer as F, seoJsonLdPlaceholder as Fn, attrTextOf as Ft, a11yInvalidAriaValue as G, seoIndexability as Gn, securitySharedStateImport as Gt, a11yAccessibleName as H, seoOgUrl as Hn, valueFromNodes as Ht, isInteractiveElement as I, seoJsonLdDateFormat as In, attrValue as It, a11yInvalidRole as J, resolveRuleOptions as Jn, securityJavascriptUrl as Jt, a11yRequiredAriaProps as K, performancePreconnect as Kn, securityServerModuleState as Kt, literalTabindexValue as L, seoJsonLdRelativeUrl as Ln, attrValueOf as Lt, a11yNoAutofocus as M, seoDescriptionLength as Mn, walkScoped as Mt, a11yNoAccesskey as N, seoTitleLength as Nn, CHILD_NODE_KEYS as Nt, HTML_SPEC as O, resolveRole as On, CATEGORIES as Or, unwrapExport as Ot, a11yPositiveTabindex as P, seoJsonLdRequiredProps as Pn, attrText as Pt, performanceLoadWaterfall as Q, applyOverrides as Qn, correctnessBasePathNavigation as Qt, a11yRequireDatetime as R, seoJsonLdDeprecatedType as Rn, findAttr as Rt, a11yPermittedContents as S, decodeFragmentId as Sn, classify as Sr, collectSuppressions as St, a11yDisallowedAriaProps as T, resolveLandmark as Tn, summarize as Tr, parseModuleProgram as Tt, a11yAriaHiddenFocus as U, seoOgDescription as Un, architecturePropCount as Ut, a11yLabelHasControl as V, seoViewport as Vn, textFromNodes as Vt, a11yInteractiveNesting as W, seoTwitterCard as Wn, architectureComponentSize as Wt, performanceStateRaw as X, validateRuleSetting as Xn, correctnessInstanceBrowserGlobal as Xt, performanceIframeLoading as Y, shouldSkipRangeCheck as Yn, securityRawHtml as Yt, performanceSequentialAwaits as Z, SEARCH_RESULT_RULES as Zn, correctnessServerBrowserGlobal as Zt, a11yIdDuplication as _, ANCESTRY_DEPENDENT_TAGS as _n, seoOgTitle as _r, collectBrowserGlobalRefs as _t, formatJsonReport as a, correctnessPropMutation as an, withIndexableOff as ar, architectureReservedDirectoryNames as at, a11yDoctype as b, NAMING_ATTRS$1 as bn, seoDescriptionPresence as br, collectNamedImportAliases as bt, formatGithubReport as c, correctnessEffectAsDerived as cn, performanceFontPreloadCrossorigin as cr, architecturePrivateScopeImport as ct, ruleMetaById as d, seoSsrDisabled as dn, performanceImageLoadingHint as dr, parseInMemoryExports as dt, correctnessOrphanEffect as en, compileOverrides as er, performanceNamespaceImport as et, severityToSarifLevel as f, routeNeverSsr as fn, performanceImageDimensions as fr, parseKitModuleFacts as ft, a11yNoMissingIdRef as g, seoSingleH1 as gn, seoJsonLd as gr, addBoundNames as gt, a11yUnverifiedIdRef as h, seoDuplicateTitle as hn, seoRobotsTxt as hr, WALK_IGNORED_KEYS as ht, buildJsonReport as i, correctnessStalePropDerivation as in, withFailedRulesOff as ir, architectureReservedNamePlacement as it, a11yNoDuplicateDt as j, seoCharset as jn, defineConfig as jr, walkEvalScope as jt, a11yPatternTitle as k, seoHreflang as kn, defaultConfig as kr, unwrapTs as kt, SEVERITY_RANK as l, correctnessEachIndexKey as ln, performancePreloadMissingAs as lr, DEFAULT_KIT_ALIASES as lt, explainRule as m, seoDuplicateDescription as mn, seoSitemapXml as mr, isRootRelativePath as mt, mdEscape as n, correctnessCheckableBindValue as nn, selectRules as nr, architectureDocLinkTarget as nt, computeHealth as o, correctnessUnmutatedState as on, performanceRenderBlockingScript as or, architectureDirectoryNaming as ot, allRules as p, seoHeadingLevelSkip as pn, seoHtmlLang as pr, resolveRepoLocalPath as pt, a11yUnknownAriaAttribute as q, isPlainObject as qn, securityHandlerStateWrite as qt, terminalSafe as r, correctnessNonreactiveBuiltinState as rn, settingSeverity as rr, architectureRouteComponentImport as rt, computeScore as s, correctnessEffectAsOnMount as sn, performanceLcpImage as sr, architectureUnitEntryFile as st, formatMarkdownReport as t, correctnessAutoplayMuted as tn, formatFailedRuleWarning as tr, performanceHeavyImport as tt, messageText as u, correctnessEachKey as un, performanceResponsiveImage as ur, collectTopLevelBindings as ut, a11yTopLevelLandmark as v, ASIDE_DEMOTING_TAGS as vn, seoOgImage as vr, collectBrowserGuardImports as vt, a11yDeprecatedAria as w, isTopFragment as wn, hasFailureAtOrAbove as wr, matchLifecycleCall as wt, a11yRequiredElement as x, SECTIONING_TAGS as xn, seoTitlePresence as xr, collectProgramBindings as xt, a11yDuplicateLandmark as y, IDREF_ATTRS as yn, seoCanonicalUrl as yr, collectDerivedGuardBindings as yt, a11yPlaceholderLabelOption as z, seoJsonLdValidity as zn, lineOf as zt };
+export { performanceLoadWaterfall as $, shouldSkipRangeCheck as $n, securityJavascriptUrl as $t, a11yPatternTitle as A, splitTokens as An, seoTitlePresence as Ar, parseModuleProgram as At, a11yPlaceholderLabelOption as B, seoJsonLdDateFormat as Bn, defineConfig as Br, attrTextOf as Bt, a11yPermittedContents as C, IDREF_ATTRS as Cn, seoCanonicalUrl as Cr, collectBrowserGuardImports as Ct, a11yDeprecatedAttr as D, foldOccurrences as Dn, layoutNeverRenders as Dr, collectSuppressions as Dt, a11yDisallowedAriaProps as E, decodeFragmentId as En, seoDescriptionPresence as Er, collectProgramBindings as Et, a11yPositiveTabindex as F, seoCharset as Fn, docsUrlFor as Fr, walkEstree as Ft, a11yInteractiveNesting as G, seoViewport as Gn, parseSvelte as Gt, a11yLabelHasControl as H, seoJsonLdDeprecatedType as Hn, attrValueOf as Ht, isInteractiveContainer as I, seoDescriptionLength as In, isPenalized as Ir, walkEvalScope as It, a11yUnknownAriaAttribute as J, seoTwitterCard as Jn, architecturePropCount as Jt, a11yInvalidAriaValue as K, seoOgUrl as Kn, textFromNodes as Kt, isInteractiveElement as L, seoTitleLength as Ln, CATEGORIES as Lr, walkScoped as Lt, a11yNoDuplicateDt as M, resolveRole as Mn, effectiveSeverity as Mr, scopeIntroducedNames as Mt, a11yNoAutofocus as N, seoHreflang as Nn, hasFailureAtOrAbove as Nr, unwrapExport as Nt, a11yDeprecatedElement as O, isTopFragment as On, pageRendersOnlyWhenBuilding as Or, collectSvelteLifecycleImports as Ot, a11yNoAccesskey as P, seoImageAlt as Pn, summarize as Pr, unwrapTs as Pt, performanceSequentialAwaits as Q, resolveRuleOptions as Qn, securityHandlerStateWrite as Qt, literalTabindexValue as R, seoJsonLdRequiredProps as Rn, defaultConfig as Rr, CHILD_NODE_KEYS as Rt, a11yRequiredElement as S, ASIDE_DEMOTING_TAGS as Sn, seoOgImage as Sr, collectBrowserGlobalRefs as St, a11yDeprecatedAria as T, SECTIONING_TAGS as Tn, isClassicScriptType as Tr, collectNamedImportAliases as Tt, a11yAccessibleName as U, seoJsonLdValidity as Un, findAttr as Ut, a11yUseList as V, seoJsonLdRelativeUrl as Vn, attrValue as Vt, a11yAriaHiddenFocus as W, seoSitemapInRobots as Wn, lineOf as Wt, performanceIframeLoading as X, performancePreconnect as Xn, securitySharedStateImport as Xt, a11yInvalidRole as Y, seoIndexability as Yn, architectureComponentSize as Yt, performanceStateRaw as Z, isPlainObject as Zn, securityServerModuleState as Zt, a11yNoMissingIdRef as _, seoHeadingLevelSkip as _n, seoHtmlLang as _r, parseKitModuleFacts as _t, formatJsonReport as a, correctnessOrphanEffect as an, formatFailedRuleWarning as ar, architectureReservedNamePlacement as at, a11yDuplicateLandmark as b, seoSingleH1 as bn, seoJsonLd as br, WALK_IGNORED_KEYS as bt, computeScore as c, correctnessNonreactiveBuiltinState as cn, withFailedRulesOff as cr, architectureUnitEntryFile as ct, messageText as d, correctnessUnmutatedState as dn, performanceLcpImage as dr, collectFalseExports as dt, securityRawHtml as en, validateRuleSetting as er, performanceMinifyDisabled as et, ruleMetaById as f, correctnessEffectAsOnMount as fn, performanceFontPreloadCrossorigin as fr, collectTopLevelBindings as ft, a11yUnverifiedIdRef as g, seoSsrDisabled as gn, performanceImageDimensions as gr, parseInMemoryExports as gt, explainRule as h, correctnessEachKey as hn, performanceImageLoadingHint as hr, parseFalseExports as ht, buildJsonReport as i, correctnessOrphanLifecycle as in, compileOverrides as ir, architectureRouteComponentImport as it, a11yAbbrTitle as j, stripTextDirective as jn, classify as jr, rootObjectName as jt, HTML_SPEC as k, resolveLandmark as kn, routeNeverSsr as kr, matchLifecycleCall as kt, formatGithubReport as l, correctnessStalePropDerivation as ln, withIndexableOff as lr, architecturePrivateScopeImport as lt, allRules as m, correctnessEachIndexKey as mn, performanceResponsiveImage as mr, parseExitFactoryExports as mt, mdEscape as n, correctnessServerBrowserGlobal as nn, applyOverrides as nr, performanceHeavyImport as nt, formatJsonReportChunks as o, correctnessAutoplayMuted as on, selectRules as or, architectureReservedDirectoryNames as ot, severityToSarifLevel as p, correctnessEffectAsDerived as pn, performancePreloadMissingAs as pr, parseClientExports as pt, a11yRequiredAriaProps as q, seoOgDescription as qn, valueFromNodes as qt, terminalSafe as r, correctnessBasePathNavigation as rn, applyRuleSeverities as rr, architectureDocLinkTarget as rt, computeHealth as s, correctnessCheckableBindValue as sn, settingSeverity as sr, architectureDirectoryNaming as st, formatMarkdownReport as t, correctnessInstanceBrowserGlobal as tn, SEARCH_RESULT_RULES as tr, performanceNamespaceImport as tt, SEVERITY_RANK as u, correctnessPropMutation as un, performanceRenderBlockingScript as ur, DEFAULT_KIT_ALIASES as ut, a11yIdDuplication as v, seoDuplicateDescription as vn, seoSitemapXml as vr, resolveRepoLocalPath as vt, a11yDisallowedElement as w, NAMING_ATTRS$1 as wn, hasRel as wr, collectDerivedGuardBindings as wt, a11yDoctype as x, ANCESTRY_DEPENDENT_TAGS as xn, seoOgTitle as xr, addBoundNames as xt, a11yTopLevelLandmark as y, seoDuplicateTitle as yn, seoRobotsTxt as yr, isRootRelativePath as yt, a11yRequireDatetime as z, seoJsonLdPlaceholder as zn, defaultProject as zr, attrText as zt };