@svelte-vitals/core 0.55.1 → 0.55.3

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

@@ -1,5 +1,5 @@
-import { parse } from "svelte/compiler";
 import { aria, roles } from "aria-query";
+import { parse } from "svelte/compiler";
 //#region src/types.ts
 const defaultProject = {
 	hasRobotsTxt: false,
@@ -152,7 +152,182 @@ 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) {
+	return {
+		match: (t) => t.kind === "meta" && t.name === key && t.property === void 0,
+		label: `<meta name="${key}"> should be <meta property="${key}">`,
+		recommendation: `Open Graph reads ${key} from the property attribute: change name="${key}" to property="${key}".`,
+		fix: {
+			description: `Change name="${key}" to property="${key}" on the existing tag.`,
+			snippet: `<meta property="${key}" content="…" />`,
+			lang: "svelte"
+		}
+	};
+}
 function detect(head, match) {
 	const matches = head.tags.filter(match);
 	const rank = (t) => (t.value !== "absent" ? 2 : 0) + (t.presence === "own" ? 1 : 0);
@@ -166,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);
@@ -180,18 +356,20 @@ function headTagRule(opts) {
 		async check(ctx) {
 			return (opts.appliesTo ? ctx.heads.filter(opts.appliesTo) : ctx.heads).map((head) => {
 				const detection = detect(head, opts.match);
-				const message = detection.presence === "none" ? `Missing ${opts.label}` : detection.value === "absent" ? `Empty ${opts.label}` : opts.label;
+				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: opts.recommendation,
+					recommendation: misspelled?.recommendation ?? (gated ? `${opts.recommendation} ${GATED_NOTE}` : opts.recommendation),
 					docsUrl,
-					...opts.fix ? { fix: { ...opts.fix } } : {}
+					...misspelled ? { fix: { ...misspelled.fix } } : opts.fix ? { fix: { ...opts.fix } } : {}
 				};
 			});
 		}
@@ -203,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.",
@@ -214,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.",
@@ -236,6 +453,7 @@ const seoOgImage = headTagRule({
 	title: "Open Graph image",
 	severity: "warning",
 	match: (t) => t.kind === "meta" && t.property === "og:image",
+	misspelled: ogMisspelled("og:image"),
 	label: "<meta property=\"og:image\">",
 	recommendation: "Add <meta property=\"og:image\">, or set openGraph.images on your meta component.",
 	rationale: "og:image is the preview thumbnail shown when the page is shared on social platforms; without it links render bare and get fewer clicks.",
@@ -252,6 +470,7 @@ const seoOgTitle = headTagRule({
 	title: "Open Graph title",
 	severity: "warning",
 	match: (t) => t.kind === "meta" && t.property === "og:title",
+	misspelled: ogMisspelled("og:title"),
 	label: "<meta property=\"og:title\">",
 	recommendation: "Add <meta property=\"og:title\">, or set openGraph.title on your meta component.",
 	rationale: "og:title controls the headline shown when the page is shared on social platforms, independent of the document <title>.",
@@ -510,7 +729,7 @@ const performanceResponsiveImage = imageRule({
 		snippet: "<img src=\"/hero.jpg\" srcset=\"/hero-800.jpg 800w, /hero-1600.jpg 1600w\" sizes=\"100vw\" width=\"1600\" height=\"900\" alt=\"…\" />",
 		lang: "svelte"
 	},
-	ok: (img) => img.hasSrcset
+	ok: (img) => img.hasSrcset || img.svg === true
 });
 //#endregion
 //#region src/rules/perf/link-rule.ts
@@ -541,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
@@ -558,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
@@ -647,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({
@@ -1159,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;
 				}
@@ -1252,7 +1472,7 @@ const seoTwitterCard = headTagRule({
 	id: "seo/twitter-card",
 	title: "Twitter Card",
 	severity: "info",
-	match: (t) => t.kind === "meta" && t.name === "twitter:card",
+	match: (t) => t.kind === "meta" && (t.name === "twitter:card" || t.property === "twitter:card"),
 	label: "<meta name=\"twitter:card\">",
 	recommendation: "Add <meta name=\"twitter:card\" content=\"summary_large_image\"> so X/Twitter renders a rich card.",
 	rationale: "twitter:card selects how the page renders when shared on X/Twitter; without it the platform falls back to a basic link (Open Graph tags are used as fallbacks for the rest).",
@@ -1269,6 +1489,7 @@ const seoOgDescription = headTagRule({
 	title: "Open Graph description",
 	severity: "info",
 	match: (t) => t.kind === "meta" && t.property === "og:description",
+	misspelled: ogMisspelled("og:description"),
 	label: "<meta property=\"og:description\">",
 	recommendation: "Add <meta property=\"og:description\">, or set openGraph.description on your meta component.",
 	rationale: "og:description is the summary shown under the title in social previews; without it platforms guess or show nothing, lowering click-through. The Open Graph protocol lists it as an optional property.",
@@ -1285,6 +1506,7 @@ const seoOgUrl = headTagRule({
 	title: "Open Graph URL",
 	severity: "warning",
 	match: (t) => t.kind === "meta" && t.property === "og:url",
+	misspelled: ogMisspelled("og:url"),
 	label: "<meta property=\"og:url\">",
 	recommendation: "Add <meta property=\"og:url\"> with the canonical URL, or set openGraph.url on your meta component.",
 	rationale: "og:url tells social platforms the canonical address to attribute shares and likes to, consolidating engagement on one URL. The Open Graph protocol lists it as a required property.",
@@ -2042,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));
@@ -2084,6 +2306,223 @@ const seoHreflang = {
 	}
 };
 //#endregion
+//#region src/rules/a11y/aria-data.ts
+/**
+* ARIA names `aria-query@5.3.2` does not carry. It is not the clean ARIA 1.2 snapshot it looks
+* like — it holds 1.2's 48 attributes plus three 1.3 additions — so the gap is patched by name
+* rather than by version. Every entry here is defined in the ARIA 1.3 editor's draft, which is
+* what makes reporting it as an unknown name wrong — how far implementations have got is a
+* separate question this rule does not ask. Re-check this list whenever the aria-query dependency
+* moves.
+*/
+const ARIA_1_3_ROLES = /* @__PURE__ */ new Set([
+	"comment",
+	"image",
+	"sectionheader",
+	"sectionfooter",
+	"suggestion"
+]);
+const ARIA_1_3_ATTRIBUTES = /* @__PURE__ */ new Set(["aria-colindextext", "aria-rowindextext"]);
+/**
+* Roles whose `requiredProps` row in aria-query is stale. Neither ARIA 1.2 nor the 1.3 editor's
+* draft lists required states or properties for these — the 1.3 draft re-lists inherited
+* requirements where they apply (`menuitemradio` → `aria-checked`), so the absence is deliberate
+* rather than an inheritance the table left implicit. Without this, idiomatic APG listbox and
+* tree markup is flagged.
+*/
+const NO_REQUIRED_PROPS = /* @__PURE__ */ new Set(["option", "treeitem"]);
+function isKnownRole(role) {
+	return ARIA_1_3_ROLES.has(role) || roles.has(role);
+}
+function isAbstractRole(role) {
+	return roles.get(role)?.abstract === true;
+}
+/** A concrete (non-abstract) role is the one a user agent resolves a role token list to. */
+function isConcreteRole(role) {
+	return isKnownRole(role) && !isAbstractRole(role);
+}
+/**
+* The role a user agent applies: the first token naming a concrete role, or undefined when none
+* does. Shared so the role rules cannot disagree about what a fallback list means.
+*/
+function resolveRole(tokens) {
+	return tokens.find(isConcreteRole);
+}
+function isKnownAriaAttribute(name) {
+	return ARIA_1_3_ATTRIBUTES.has(name) || aria.has(name);
+}
+function requiredAriaProps(role) {
+	if (NO_REQUIRED_PROPS.has(role)) return [];
+	const def = roles.get(role);
+	return def ? Object.keys(def.requiredProps) : [];
+}
+function ariaValueKind(name) {
+	const def = aria.get(name);
+	if (!def) return void 0;
+	return {
+		type: def.type,
+		...def.values ? { values: def.values.map(String) } : {}
+	};
+}
+//#endregion
+//#region src/a11y.ts
+/**
+* Branch-aware occurrence fold (design "Control-flow semantics"): within a branch
+* occurrences sum, across the arms of one exclusive block the arm with the most
+* occurrences wins (tie → lowest branch index) and ITS occurrences are the group's
+* representatives — so a caller's count is always `list.length`, with a location per
+* representative. `{#each}`/`{#snippet}` occurrences render 0..N times and drop out.
+* The max is per key: there is no scalar total to maximize.
+*/
+function foldOccurrences(nodes) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		if (node.repeatable) continue;
+		const list = byKey.get(node.key);
+		if (list) list.push(node);
+		else byKey.set(node.key, [node]);
+	}
+	const folded = /* @__PURE__ */ new Map();
+	for (const [key, list] of byKey) folded.set(key, foldAt(list, 0));
+	return folded;
+}
+function foldAt(nodes, depth) {
+	const unconditional = [];
+	const groups = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const step = node.path[depth];
+		if (!step) {
+			unconditional.push(node);
+			continue;
+		}
+		let branches = groups.get(step.group);
+		if (!branches) groups.set(step.group, branches = /* @__PURE__ */ new Map());
+		const list = branches.get(step.branch);
+		if (list) list.push(node);
+		else branches.set(step.branch, [node]);
+	}
+	const representatives = [...unconditional];
+	for (const branches of groups.values()) {
+		let best = [];
+		let bestBranch = Number.POSITIVE_INFINITY;
+		for (const [branch, list] of branches) {
+			const arm = foldAt(list, depth + 1);
+			if (arm.length > best.length || arm.length === best.length && branch < bestBranch) {
+				best = arm;
+				bestBranch = branch;
+			}
+		}
+		representatives.push(...best);
+	}
+	return representatives;
+}
+/**
+* Decode a fragment identifier the way navigation does before matching an element id
+* (`href="#caf%C3%A9"` targets `id="café"`). Malformed escapes are kept verbatim —
+* the browser would also fail to decode them, so the raw text is the comparable form.
+*/
+function decodeFragmentId(fragment) {
+	try {
+		return decodeURIComponent(fragment);
+	} catch {
+		return fragment;
+	}
+}
+/** Whitespace-split tokens of a (possibly undefined) literal attribute value. */
+function splitTokens(value) {
+	return value ? value.trim().split(/\s+/).filter(Boolean) : [];
+}
+/** Explicit `role` values that map to the landmark kinds the route rules inspect. */
+const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+	"main",
+	"banner",
+	"contentinfo",
+	"complementary"
+]);
+/** Sectioning content (HTML-AAM): a `<header>`/`<footer>` below one of these is not a landmark. */
+const SECTIONING_TAGS = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"main",
+	"nav",
+	"section"
+]);
+/**
+* Tags whose landmark-ness depends on sectioning ancestry. A provider that cannot see ancestry
+* (the per-file AST walk) uses this same set to mark the deferral (topLevel) — reading it from
+* here keeps the deferral set from drifting when the policy widens.
+*/
+const ANCESTRY_DEPENDENT_TAGS = /* @__PURE__ */ new Set(["header", "footer"]);
+/** Attributes that give an element the accessible name the `<aside>` landmark decision reads. */
+const NAMING_ATTRS$1 = ["aria-label", "aria-labelledby"];
+/**
+* HTML-AAM: an `<aside>` scoped to `body` or `main` is a `complementary` landmark; scoped to
+* sectioning content it is one only when it has an accessible name. `main` is deliberately absent
+* — it is a scope in which an `aside` *is* a landmark, unlike the sectioning set that decides
+* `<header>`/`<footer>`.
+*/
+const ASIDE_DEMOTING_TAGS = /* @__PURE__ */ new Set([
+	"article",
+	"aside",
+	"nav",
+	"section"
+]);
+/**
+* The landmark kind an element contributes ('main'|'banner'|'contentinfo'|'complementary'), or
+* undefined. The one home for the decision both providers apply — the source AST walk and the
+* rendered HTML walk each feed it their own tree's context. ARIA fallback role lists resolve to
+* the first token naming a concrete role (resolveRole).
+*/
+function resolveLandmark(input) {
+	const { tag, roleTokens, named, insideSectioning, insideAsideDemoting } = input;
+	if (roleTokens !== void 0) {
+		const role = resolveRole(roleTokens);
+		return role && LANDMARK_ROLES.has(role) ? role : void 0;
+	}
+	if (tag === "main") return "main";
+	if (tag !== void 0 && ANCESTRY_DEPENDENT_TAGS.has(tag)) return insideSectioning ? void 0 : tag === "header" ? "banner" : "contentinfo";
+	if (tag === "aside") return !insideAsideDemoting || named ? "complementary" : void 0;
+}
+/**
+* Attributes whose (whitespace-tokenized) values reference element ids: the ARIA id-reference and
+* id-reference-list properties, and HTML's own (`for`, `list`, `headers`, `form`, the popover and
+* command targets). `href="#…"` is handled separately — its value is a URL, not a token list.
+*/
+const IDREF_ATTRS = [
+	"for",
+	"list",
+	"headers",
+	"form",
+	"popovertarget",
+	"commandfor",
+	"aria-labelledby",
+	"aria-describedby",
+	"aria-controls",
+	"aria-activedescendant",
+	"aria-owns",
+	"aria-details",
+	"aria-errormessage",
+	"aria-flowto"
+];
+/**
+* Whether a decoded URL fragment is HTML's "top of the document" indicator: `#top` (ASCII
+* case-insensitive) scrolls to the top when no element has that id, so it is never a missing
+* reference. Compare AFTER percent-decoding — `#%74op` navigates identically to `#top`.
+*/
+function isTopFragment(id) {
+	return id.toLowerCase() === "top";
+}
+/**
+* A fragment with its text directive removed. Everything from the first `:~:` on is user-agent
+* instructions for finding text and names no element, while anything before it is still an
+* ordinary element fragment — `#section:~:text=hi` targets `id="section"`, `#:~:text=hi` targets
+* nothing. Returns an empty string when the fragment is a directive and nothing else.
+*/
+function stripTextDirective(fragment) {
+	const i = fragment.indexOf(":~:");
+	return i === -1 ? fragment : fragment.slice(0, i);
+}
+//#endregion
 //#region src/rules/seo/single-h1.ts
 const docsUrl$6 = docsUrlFor("seo/single-h1");
 const passRecommendation = "Use exactly one <h1> per page for its main topic; demote extra top-level headings to <h2>+.";
@@ -2098,10 +2537,24 @@ const multipleRecommendation = "A single, clear <h1> is the conventional signal
 * signal, but no official source documents a ranking penalty for several (2026-08-09 v1
 * rule-validity review, P2 #11) — so it's flagged as a style nit, not a defect. Exactly
 * one passes. A route whose headings were not collected (channel unset) emits nothing, as does
-* one whose `dynamicHeading` flag says an undeterminable `<svelte:element>` may be its <h1>. A
+* one whose `dynamicHeading` flag says a heading of undeterminable level may be its <h1>. A
 * global `rules: { 'seo/single-h1': <severity> }` override flattens both arms to one
 * severity (design, `applyRuleSeverities`).
 */
+/**
+* The <h1>s that can render together, in input order: the arms of one `{#if}`/`{#await}`/
+* `<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 && !h.aria).map((heading) => ({
+		key: "h1",
+		path: heading.path ?? [],
+		repeatable: false,
+		heading
+	}));
+	const kept = new Set([...foldOccurrences(nodes).values()].flat().map((n) => n.heading));
+	return headings.filter((h) => kept.has(h));
+}
 const seoSingleH1 = {
 	id: "seo/single-h1",
 	title: "Heading hierarchy",
@@ -2112,7 +2565,7 @@ const seoSingleH1 = {
 	async check(ctx) {
 		const out = [];
 		for (const route of ctx.headings ?? []) {
-			const h1 = [...route.headings, ...route.componentHeadings ?? []].filter((h) => h.level === 1);
+			const h1 = renderableH1s([...route.headings, ...route.componentHeadings ?? []]);
 			let problem;
 			let where = {};
 			if (h1.length === 0) {
@@ -2122,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 } : {}
@@ -2246,8 +2699,23 @@ const seoDuplicateDescription = uniquenessRule({
 	rationale: "Duplicate meta descriptions give search engines no per-page summary, so they are often ignored or rewritten."
 });
 //#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;
+	return a.path.some((s) => b.path.some((t) => s.group === t.group && s.branch !== t.branch));
+}
+//#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
@@ -2266,20 +2734,36 @@ const seoHeadingLevelSkip = {
 		const out = [];
 		for (const route of ctx.headings ?? []) {
 			if (route.headings.length === 0) continue;
-			let prev = route.headings[0].level;
+			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; i++) {
-				const h = route.headings[i];
-				if (h.level > prev + 1) {
-					skip = {
-						level: h.level,
-						prev,
-						line: h.line,
-						file: h.file
-					};
-					break;
+			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);
+					}
 				}
-				prev = h.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: lowest,
+					line: h.line,
+					file: h.file
+				};
 			}
 			out.push(skip ? {
 				id: "seo/heading-level-skip",
@@ -2410,10 +2894,6 @@ function kitModuleRule(opts) {
 }
 //#endregion
 //#region src/rules/seo/ssr-disabled.ts
-/** The root layout — disabling SSR there turns the whole app into an SPA. */
-const ROOT_LAYOUT_RE = /^src\/routes\/\+layout(\.server)?\.(ts|js)$/;
-/** `ssr` 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 seoSsrDisabled = kitModuleRule({
 	id: "seo/ssr-disabled",
 	title: "SSR disabled",
@@ -2755,9 +3235,19 @@ function messageFor(link) {
 	if (link.kind === "goto") return `goto('${link.path}') is root-relative — it navigates outside this project's kit.paths.base and 404s in production. Use goto(resolve('${link.path}')) with resolve from '$app/paths'.`;
 	return `redirect(…, '${link.path}') is root-relative — the Location header points outside this project's kit.paths.base and 404s in production. Use resolve('${link.path}') from '$app/paths'.`;
 }
+/**
+* A literal that already carries a statically known base is correct as written; only a dynamic
+* base (no `value`) leaves every root-relative literal suspect.
+*/
+function startsWithBase(path, base) {
+	if (base === void 0 || !path.startsWith(base)) return false;
+	if (/(^|\/)(\.|%2e){2}(\/|$)/i.test(path.split(/[?#]/)[0])) return false;
+	const next = path.charAt(base.length);
+	return next === "" || next === "/" || next === "?" || next === "#";
+}
 /** Emit one file's PASS/PENALIZED results — same shapes as componentRule/kitModuleRule. */
-function emitFile$1(out, file, links, suppressions) {
-	const bad = links.filter((l) => !(l.line > 0 && isSuppressed(suppressions, ID$8, l.line)));
+function emitFile$1(out, file, links, suppressions, base) {
+	const bad = links.filter((l) => !startsWithBase(l.path, base) && !(l.line > 0 && isSuppressed(suppressions, ID$8, l.line)));
 	if (bad.length === 0) {
 		out.push({
 			id: ID$8,
@@ -2802,16 +3292,17 @@ const correctnessBasePathNavigation = {
 	fix: { ...FIX$2 },
 	async check(ctx) {
 		if (!ctx.project.kitPathsBase) return [];
+		const base = ctx.project.kitPathsBase.value;
 		const out = [];
 		for (const c of ctx.components ?? []) {
 			const links = c.basePathLinks ?? [];
 			if (links.length === 0) continue;
-			emitFile$1(out, c.file, links, c.suppressions);
+			emitFile$1(out, c.file, links, c.suppressions, base);
 		}
 		for (const m of ctx.kitModules ?? []) {
 			const links = m.basePathLinks ?? [];
 			if (links.length === 0) continue;
-			emitFile$1(out, m.file, links, m.suppressions);
+			emitFile$1(out, m.file, links, m.suppressions, base);
 		}
 		return out;
 	}
@@ -2878,7 +3369,8 @@ const correctnessServerBrowserGlobal = {
 			})), c.suppressions);
 		}
 		for (const m of ctx.kitModules ?? []) {
-			const refs = m.browserGlobalRefs ?? [];
+			const neverSsr = universalNeverSsr(m, ctx);
+			const refs = (m.browserGlobalRefs ?? []).filter((r) => !(neverSsr && r.inHandler));
 			if (refs.length === 0) continue;
 			emitFile(out, m.file, refs.map((r) => ({
 				line: r.line,
@@ -2897,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) => (c.browserGlobalRefs ?? []).some((r) => r.context === "instance"),
+	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`
@@ -2943,7 +3435,7 @@ const securityHandlerStateWrite = kitModuleRule({
 	label: "Load/handler purity",
 	recommendation: "Return the data from load (or the action) and pass it via page data instead of writing it to module state; per-user data belongs in cookies/locals plus a database. Caches and rate limiters keyed by non-personal data are the benign shape — if that describes this write, add an inline suppression.",
 	rationale: "SvelteKit's docs mark this NEVER-DO-THIS: the server is one long-lived process shared by every user, so module state written during a request is visible to ALL later requests.",
-	applies: (m) => m.importedStateWrites.length > 0 && !(m.kind === "universal" && m.ssrDisabled),
+	applies: (m, ctx) => m.importedStateWrites.length > 0 && !universalNeverSsr(m, ctx),
 	bad: (m) => m.importedStateWrites.map((w) => ({
 		line: w.line,
 		message: `a server-executed handler writes imported module state "${w.name}" — module state is shared across all requests on the server; if this holds per-request or per-user data, one user's data can leak to another. Caches and rate limiters keyed by non-personal data are the benign shape — verify which this is`
@@ -2958,7 +3450,7 @@ const securityServerModuleState = kitModuleRule({
 	label: "Server module state",
 	recommendation: "Do not keep request data in module scope on the server — authenticate with cookies/locals and persist per-user data in a database. For a deliberate process-wide cache, prefer a const container (e.g. a Map) or add an inline suppression.",
 	rationale: "Module scope on the server is one shared, long-lived instance (SvelteKit docs: \"Avoid shared state on the server\"): a value reassigned during one user's request is served to every other user, and it silently resets on every deploy or restart.",
-	applies: (m) => m.moduleStateReassignments.length > 0,
+	applies: (m, ctx) => m.moduleStateReassignments.length > 0 && !universalNeverSsr(m, ctx),
 	bad: (m) => m.moduleStateReassignments.map((r) => ({
 		line: r.line,
 		message: r.inHandler ? `module-scope variable "${r.name}" is reassigned from a request handler — its value is shared across all requests on the server` : `module-scope variable "${r.name}" is reassigned from a function — if it runs during a request, the value is shared across all requests on the server`
@@ -2977,7 +3469,7 @@ const securitySharedStateImport = kitModuleRule({
 	label: "Server state imports",
 	recommendation: "Keep module-scope $state out of server-executed code: return data from load and share it via page data or the context API. If the module is genuinely client-only, restructure so server files do not import it, or add an inline suppression.",
 	rationale: "A .svelte.ts module with module-scope $state is one shared instance on the server: mutated, it leaks data between users; read-only, every request sees the same boot-time value instead of per-user data.",
-	applies: (m) => m.runesModuleImports.length > 0 && !(m.kind === "universal" && m.ssrDisabled),
+	applies: (m, ctx) => m.runesModuleImports.length > 0 && !universalNeverSsr(m, ctx),
 	bad: (m, ctx) => {
 		const stateFiles = new Set((ctx.components ?? []).filter((c) => c.moduleStateDecls.length > 0).map((c) => c.file));
 		const writtenOutside = new Set(m.importedStateWritesOutsideHandlers.map((w) => w.name));
@@ -3085,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,
@@ -3151,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
@@ -3189,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). */
@@ -3242,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;
 }
 /**
@@ -3258,7 +3764,8 @@ function rootObjectName(node) {
 * `then`/`catch` value/error bindings, and a fragment's own `{@const ...}` /
 * `{let ...}` / `{const ...}` declaration tags (attributed to the enclosing Fragment,
 * shadowing the whole fragment like a block's `let` — a write to one of these
-* template-locals, possible for `{let}`, is still not a write to the outer binding).
+* template-locals, possible for `{let}`, is still not a write to the outer binding), and an
+* element's or component's `let:` directive bindings.
 * Used by `walkScoped` so a write/mutation detector
 * doesn't misattribute a write to one of these locals as a write to an outer `$state`/prop
 * of the same name (issue #140 — originally a deliberately partial mitigation that left
@@ -3284,7 +3791,20 @@ function scopeIntroducedNames(node) {
 	else if (node.type === "AwaitBlock") {
 		if (node.value) addBoundNames(node.value, introduced);
 		if (node.error) addBoundNames(node.error, introduced);
-	} else if (node.type === "Fragment") {
+	} else if (Array.isArray(node.attributes) && node.fragment) for (const attr of node.attributes) {
+		if (attr?.type !== "LetDirective") continue;
+		const e = attr.expression;
+		const asPattern = {
+			ObjectExpression: "ObjectPattern",
+			ArrayExpression: "ArrayPattern"
+		}[e?.type];
+		if (e) addBoundNames(asPattern ? {
+			...e,
+			type: asPattern
+		} : e, introduced);
+		else introduced.add(attr.name);
+	}
+	else if (node.type === "Fragment") {
 		for (const child of node.nodes ?? []) if (child?.type === "ConstTag" || child?.type === "DeclarationTag") for (const d of child.declaration?.declarations ?? []) addBoundNames(d.id, introduced);
 	}
 	return introduced;
@@ -3340,11 +3860,21 @@ function walkEvalScope(node, visit, shadowed = /* @__PURE__ */ new Set(), bounda
 	const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
 	if (visit(node, scope)) return;
 	if (boundaries.has(node.type)) return;
+	const outer = introduced.size > 0 ? outerScopeKeys(node) : void 0;
 	for (const key of Object.keys(node)) {
 		if (WALK_IGNORED_KEYS.has(key)) continue;
-		walkEvalScope(node[key], visit, scope, boundaries);
+		if (!outer?.has(key)) walkEvalScope(node[key], visit, scope, boundaries);
+		else if (!Array.isArray(node[key])) walkEvalScope(node[key], visit, shadowed, boundaries);
+		else for (const child of node[key]) walkEvalScope(child, visit, child?.type === "LetDirective" ? scope : shadowed, boundaries);
 	}
 }
+/** Children of a binding construct that are evaluated before its bindings exist. */
+function outerScopeKeys(node) {
+	if (node.type === "EachBlock" || node.type === "AwaitBlock") return OUTER_SCOPE_KEYS;
+	if (Array.isArray(node.attributes) && node.fragment) return ATTRIBUTE_KEYS;
+}
+const OUTER_SCOPE_KEYS = /* @__PURE__ */ new Set(["expression"]);
+const ATTRIBUTE_KEYS = /* @__PURE__ */ new Set(["attributes"]);
 /**
 * Unwrap a top-level statement's `export`/`export default` wrapper to the declaration
 * (or expression) it wraps; a non-export statement is returned as-is. Used so pattern 2
@@ -3449,12 +3979,13 @@ function collectNamedImportAliases(program, moduleSource, names) {
 }
 const BROWSER_GUARD_NAMES = /* @__PURE__ */ new Set(["browser"]);
 /**
-* Local names of `browser` value-imported from '$app/environment' (alias-resolved) —
+* Local names of `browser` value-imported from '$app/environment' or its SvelteKit 3 name
+* '$app/env' (alias-resolved) —
 * the guard binding recognised by the browser-global scanner (correctness/server-browser-global, correctness/instance-browser-global).
 * Shared with the Kit-module parser.
 */
 function collectBrowserGuardImports(program) {
-	return collectNamedImportAliases(program, "$app/environment", BROWSER_GUARD_NAMES);
+	return /* @__PURE__ */ new Set([...collectNamedImportAliases(program, "$app/environment", BROWSER_GUARD_NAMES), ...collectNamedImportAliases(program, "$app/env", BROWSER_GUARD_NAMES)]);
 }
 /**
 * Names bound at the program's top level: every import's local name plus every
@@ -3470,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);
@@ -3490,10 +4026,12 @@ function guardTerminates(consequent) {
 /**
 * Whether a guard-clause test establishes a browser environment: it references the
 * `$app/environment` `browser` binding, or contains a
-* `typeof <tracked-global> === | !== 'undefined'` comparison (correctness/server-browser-global, correctness/instance-browser-global).
+* `typeof <tracked-global>` comparison against any type string (`'undefined'`, `'function'`, …)
+* (correctness/server-browser-global, correctness/instance-browser-global).
 * Over-matching here only widens the skip — a conservative miss, never a false positive.
 */
 function isBrowserGuardTest(test, guardBindings) {
+	if (test?.type === "LogicalExpression" && test.operator !== "&&") return isBrowserGuardTest(test.left, guardBindings) && isBrowserGuardTest(test.right, guardBindings);
 	let guarded = false;
 	walkEstree(test, (n) => {
 		if (n.type === "Identifier" && guardBindings.has(n.name)) guarded = true;
@@ -3505,12 +4043,20 @@ function isBrowserGuardTest(test, guardBindings) {
 		].includes(n.operator)) {
 			const sides = [n.left, n.right];
 			const hasTypeofGlobal = sides.some((s) => s?.type === "UnaryExpression" && s.operator === "typeof" && s.argument?.type === "Identifier" && BROWSER_GLOBALS.has(s.argument.name));
-			const hasUndefinedString = sides.some((s) => s?.type === "Literal" && s.value === "undefined");
-			if (hasTypeofGlobal && hasUndefinedString) guarded = true;
+			const type = sides.find((s) => s?.type === "Literal" && typeof s.value === "string")?.value;
+			const positive = n.operator === "===" || n.operator === "==";
+			if (hasTypeofGlobal && type !== void 0 && (type === "undefined" || positive)) guarded = true;
 		}
 	});
 	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` —
@@ -3530,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
@@ -3564,7 +4199,13 @@ function collectBrowserGlobalRefs(program, source, extra) {
 		if (typeof n !== "object" || typeof n.type !== "string") return;
 		if (EVAL_SCOPE_BOUNDARIES.has(n.type)) return;
 		if ((n.type === "IfStatement" || n.type === "ConditionalExpression") && isBrowserGuardTest(n.test, guards)) return;
-		if (n.type === "LogicalExpression" && isBrowserGuardTest(n.left, 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) {
@@ -3659,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";
 }
@@ -3760,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
@@ -3768,14 +4414,41 @@ 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;
+}
+/** Whether the module exports a binding named `name` in any form, re-exports and unresolved aliases included. */
+function exportsName(program, name) {
+	return (program.body ?? []).some((stmt) => {
+		if (stmt?.type !== "ExportNamedDeclaration" || stmt.exportKind === "type") return false;
+		const decl = stmt.declaration;
+		if (decl?.type === "VariableDeclaration") return decl.declarations?.some((d) => d?.id?.name === name);
+		if (decl) return decl.id?.name === name;
+		return (stmt.specifiers ?? []).some((s) => s?.exportKind !== "type" && (s?.exported?.name ?? s?.exported?.value) === name);
+	});
+}
 /**
 * The exported `load` function node (inline `export function load` / `export const
 * load = …`, `satisfies`/`as` unwrapped) or a same-file alias export. Cross-file
@@ -3805,7 +4478,25 @@ function collectAwaits(node, out = []) {
 	}
 	return out;
 }
+const MUTATING_METHODS = /* @__PURE__ */ new Set([
+	"push",
+	"unshift",
+	"splice",
+	"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
@@ -3826,6 +4517,359 @@ 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);
+	if (!node || typeof node !== "object" || typeof node.type !== "string" || isFunctionNode(node)) return false;
+	if (node.type === "ReturnStatement") return true;
+	return Object.keys(node).some((key) => !WALK_IGNORED_KEYS.has(key) && containsReturn(node[key]));
+}
+/**
+* Whether the exported `load` redirects or errors on every call: every path through its body reaches a
+* `redirect(…)` / `error(…)` (thrown or not) before any `return` — through both arms of an `if`/`else`,
+* through a `try` whose `catch` redirects or rethrows, and through a call to a top-level function
+* 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, building = /* @__PURE__ */ new Set()) {
+	const load = locals.size > 0 ? findLoadFunction(program) : void 0;
+	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();
+		for (const p of fn.params ?? []) addBoundNames(p, shadow);
+		const frame = {
+			seen: /* @__PURE__ */ new Set([...seen, fn]),
+			observed
+		};
+		return fn.body?.type === "BlockStatement" ? always(fn.body.body, shadow, void 0, frame) : isRedirect(fn.body, shadow, frame, observed);
+	};
+	const isRedirect = (expr, shadow, frame, returned = false) => {
+		let e = unwrapTs(expr);
+		const awaited = e?.type === "AwaitExpression";
+		if (awaited) e = unwrapTs(e.argument);
+		if (e?.type !== "CallExpression" || e.callee?.type !== "Identifier" || shadow.has(e.callee.name)) return false;
+		if (locals.has(e.callee.name)) return true;
+		const fn = topLevel.get(e.callee.name);
+		if (!isFunctionNode(fn) || fn.generator || frame.seen.has(fn) || fn.async && !awaited && !returned) return false;
+		return fnRedirects(fn, frame.seen, awaited || returned);
+	};
+	const within = (body, outer, param) => {
+		const own = /* @__PURE__ */ new Set();
+		addBoundNames(param, own);
+		for (const stmt of body ?? []) if (stmt?.type === "VariableDeclaration") for (const d of stmt.declarations ?? []) addBoundNames(d?.id, own);
+		else if ((stmt?.type === "FunctionDeclaration" || stmt?.type === "ClassDeclaration") && stmt.id) addBoundNames(stmt.id, own);
+		return own.size === 0 ? outer : /* @__PURE__ */ new Set([...outer, ...own]);
+	};
+	const redirects = (stmt, shadow, rethrow, frame) => {
+		if (stmt?.type === "ExpressionStatement") return isRedirect(stmt.expression, shadow, frame);
+		if (stmt?.type === "ThrowStatement" || stmt?.type === "ReturnStatement") {
+			if (isRedirect(stmt.argument, shadow, frame, stmt.type === "ReturnStatement" && frame.observed)) return true;
+			return stmt.type === "ThrowStatement" && stmt.argument?.type === "Identifier" && stmt.argument.name === rethrow;
+		}
+		if (stmt?.type === "BlockStatement") return always(stmt.body, shadow, rethrow, frame);
+		if (stmt?.type === "IfStatement") return !!stmt.alternate && redirects(stmt.consequent, shadow, rethrow, frame) && redirects(stmt.alternate, shadow, rethrow, frame);
+		if (stmt?.type === "TryStatement") {
+			const param = stmt.handler?.param?.type === "Identifier" ? stmt.handler.param.name : void 0;
+			return always(stmt.block?.body, shadow, void 0, frame) && (!stmt.handler || always(stmt.handler.body?.body, within([], shadow, stmt.handler.param), param, frame)) && !containsReturn(stmt.finalizer);
+		}
+		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 (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 (plainReturn(stmt, shadow, frame)) return false;
+		}
+		return false;
+	};
+	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
 * step, exempt from performance/load-waterfall and performance/sequential-awaits). Any `<expr>.parent()` member call matches — over-broad
 * in the false-negative direction only, which is the conservative side.
@@ -3845,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
@@ -3853,9 +4898,32 @@ 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",
+	"NewExpression",
+	"ImportExpression",
+	"TaggedTemplateExpression"
+]);
+/** Whether an await argument starts work (a call, tagged template, `new`, or `import()`), as opposed to awaiting an existing promise. */
+function startsWork(arg) {
+	let e = unwrapTs(arg);
+	if (e?.type === "ChainExpression") e = e.expression;
+	return WORK_STARTING.has(e?.type);
+}
+/** Whether evaluating `node` may start work: a work-starting expression anywhere outside a nested function. */
+function containsWork(node) {
+	if (Array.isArray(node)) return node.some(containsWork);
+	if (!node || typeof node !== "object" || typeof node.type !== "string") return false;
+	if (isFunctionNode(node)) return false;
+	if (WORK_STARTING.has(node.type)) return true;
+	return Object.keys(node).some((key) => !WALK_IGNORED_KEYS.has(key) && containsWork(node[key]));
 }
 /**
 * Whether the expression references any tainted name. Threads nested-function
@@ -3889,15 +4957,36 @@ function refsTainted(node, tainted) {
 	return hit;
 }
 /**
+* Awaits that only run when a tainted value says so — `a ?? await x`, `t ? await x : y` — and so
+* cannot start before the earlier await that decides them.
+*/
+function guardedAwaits(node, tainted, out = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(node)) {
+		for (const child of node) guardedAwaits(child, tainted, out);
+		return out;
+	}
+	if (!node || typeof node !== "object" || typeof node.type !== "string" || isFunctionNode(node)) return out;
+	if (node.type === "LogicalExpression" && refsTainted(node.left, tainted)) for (const a of collectAwaits(node.right)) out.add(a);
+	else if (node.type === "ConditionalExpression" && refsTainted(node.test, tainted)) for (const a of collectAwaits([node.consequent, node.alternate])) out.add(a);
+	for (const key of Object.keys(node)) {
+		if (WALK_IGNORED_KEYS.has(key)) continue;
+		guardedAwaits(node[key], tainted, out);
+	}
+	return out;
+}
+/**
 * performance/load-waterfall, performance/sequential-awaits — forward-taint analysis of the exported `load`'s straight-line
 * statements (direct `try` blocks inlined; `if`/loops/`switch` are not classified
 * but still propagate taint from their assignments; nested functions are never
 * entered). One await site per statement; a site whose awaits' argument subtrees
 * reference an earlier site's bindings (transitively, through intermediate consts
-* and assignments — member-expression targets taint their root object) is
-* dependent, anchored at the first dependent await; otherwise independent when a
-* prior site exists, unless every await merely resumes an already-created promise
-* (a bare identifier argument starts no request). `await parent()` and
+* and assignments — member-expression targets taint their root object), or that a
+* tainted `??`/`&&`/`||`/`?:` guard decides (`guardedAwaits`), is
+* dependent, anchored at the first dependent await — unless it starts no work and its
+* promise came straight from an await result (`await deferred.state` after
+* `await parent()`); otherwise independent when a prior site exists, unless every
+* await merely resumes an already-created promise (a bare identifier argument starts
+* no request). `await parent()` and
 * response-body reads are never sites, but their bindings taint. Lines are
 * returned in ORIGINAL-source coordinates (the −1 wrap shift is applied here).
 */
@@ -3911,12 +5000,60 @@ 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 taintAssignTarget = (left) => {
-		if (left?.type === "MemberExpression") {
-			const root = rootObjectName(left);
-			if (root) tainted.add(root);
-		} else addBoundNames(left, tainted);
+	const taintTarget = (target, rhs) => {
+		const awaited = collectAwaits(rhs).length > 0;
+		if (!awaited && !refsTainted(rhs, tainted)) return;
+		const names = /* @__PURE__ */ new Set();
+		if (target?.type === "MemberExpression") {
+			const root = rootObjectName(target);
+			if (root) names.add(root);
+		} else addBoundNames(target, names);
+		for (const name of names) {
+			tainted.add(name);
+			if (!awaited && (containsWork(rhs) || refsTainted(rhs, syncTainted))) syncTainted.add(name);
+		}
+	};
+	const taintMutation = (call) => {
+		const callee = unwrapTs(call?.callee);
+		if (call?.type !== "CallExpression" || callee?.type !== "MemberExpression" || callee.computed) return;
+		if (!MUTATING_METHODS.has(callee.property?.name) || !(call.arguments ?? []).some((a) => refsTainted(a, tainted))) return;
+		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)) {
@@ -3925,10 +5062,19 @@ function collectLoadWaterfalls(program, wrapped) {
 		}
 		if (!node || typeof node !== "object" || typeof node.type !== "string") return;
 		if (isFunctionNode(node)) return;
-		if (node.type === "AssignmentExpression") {
-			if (collectAwaits(node.right).length > 0 || refsTainted(node.right, tainted)) taintAssignTarget(node.left);
+		if (node.type === "AssignmentExpression") taintTarget(node.left, node.right);
+		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 && (collectAwaits(d.init).length > 0 || refsTainted(d.init, tainted))) addBoundNames(d.id, tainted);
+			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;
@@ -3947,12 +5093,13 @@ function collectLoadWaterfalls(program, wrapped) {
 			if (stmt.type === "VariableDeclaration" || stmt.type === "ExpressionStatement" || stmt.type === "ReturnStatement") {
 				const sites = collectAwaits(stmt).filter((a) => !isParentCall(a.argument) && !isBodyParseCall(a.argument));
 				if (sites.length > 0) {
-					const dependent = sites.filter((a) => refsTainted(a.argument, tainted));
+					const guarded = guardedAwaits(stmt, tainted);
+					const dependent = sites.filter((a) => (guarded.has(a) || refsTainted(a.argument, tainted)) && (startsWork(a.argument) || refsTainted(a.argument, syncTainted)));
 					if (dependent.length > 0) {
 						const anchor = dependent.reduce((m, a) => a.start < m.start ? a : m);
 						dependentLines.push(line(anchor.start));
 					} else if (sawAwaitSite) {
-						const workSites = sites.filter((a) => unwrapTs(a.argument)?.type !== "Identifier");
+						const workSites = sites.filter((a) => startsWork(a.argument));
 						if (workSites.length > 0) {
 							const anchor = workSites.reduce((m, a) => a.start < m.start ? a : m);
 							independentLines.push(line(anchor.start));
@@ -3960,15 +5107,22 @@ function collectLoadWaterfalls(program, wrapped) {
 					}
 					sawAwaitSite = true;
 				}
-				if (stmt.type === "VariableDeclaration") for (const d of stmt.declarations ?? []) {
-					if (!d?.id || !d.init) continue;
-					if (collectAwaits(d.init).length > 0 || refsTainted(d.init, tainted)) addBoundNames(d.id, tainted);
-				}
-				else if (stmt.type === "ExpressionStatement") {
+				if (stmt.type === "VariableDeclaration") {
+					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") {
-						if (collectAwaits(expr.right).length > 0 || refsTainted(expr.right, tainted)) taintAssignTarget(expr.left);
+					if (expr?.type === "AssignmentExpression") taintTarget(expr.left, expr.right);
+					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);
 		}
@@ -4005,23 +5159,19 @@ function walkKit(node, handlerFns, startupFns, visit, shadowed = /* @__PURE__ */
 	}
 }
 /**
-* Normalize a posix path, resolving `.` and `..` segments — string-only, no I/O.
-* Returns undefined when a `..` segment pops an empty stack, i.e. the path escapes
-* its root (e.g. `../../../../src/lib/server/db` from a shallow route file): the
-* real target lies outside the project tree we can see, so there is no
-* project-relative path to return at all.
+* Normalize a posix path, resolving `.` and `..` segments — string-only, no I/O. `..` segments
+* that climb above the root are kept as a leading `../` run (`../../plugins/x`).
 */
 function normalizePosix(path) {
 	const out = [];
 	for (const seg of path.split("/")) {
 		if (seg === "" || seg === ".") continue;
-		if (seg === "..") {
-			if (out.length === 0) return void 0;
-			out.pop();
-		} else out.push(seg);
+		if (seg === ".." && out.length > 0 && out[out.length - 1] !== "..") out.pop();
+		else out.push(seg);
 	}
 	return out.join("/");
 }
+const escapesRoot = (path) => path === ".." || path.startsWith("../");
 /**
 * What `resolveRepoLocalPath` assumes when no config was read: SvelteKit's own `$lib`, at the
 * default `src/lib`. This single entry is the whole of this analyzer's pre-alias behaviour.
@@ -4048,8 +5198,12 @@ function aliasMatches(entry, spec) {
 * be a project-local module: the caller's `aliases` list decides which non-relative
 * specifiers resolve, defaulting to `$lib` → `src/lib`; `./`/`../` resolve against the
 * importing file's directory; bare packages and other aliases are skipped (they can't
-* be resolved to a project-local path at all). Also undefined when a relative
-* specifier's `..` segments escape the project root (see `normalizePosix`), or when a
+* be resolved to a project-local path at all). A path above the project root (a leading `../`
+* run) resolves only inside a directory a `kit.alias` value itself names above the root
+* (`$plugins: '../../plugins'` in a monorepo app): the user's config says the app builds from
+* there, so it is read like `src/` — likewise inside a workspace package's directory an entry
+* names as its `root` — and anywhere else above the root is undefined, as nothing says the app
+* reaches it. Also undefined when a
 * matched alias's value is itself absolute (e.g. `/opt/shared/src`, or a posixified Windows
 * drive-letter path like `C:/shared/src`): an absolute target is outside the analyzed project by
 * definition, and without this check `normalizePosix` would quietly drop the leading empty
@@ -4058,21 +5212,27 @@ function aliasMatches(entry, spec) {
 * Exported from the package's public barrel because `architecture/private-scope-import`
 * and `architecture/route-component-import` (inside `packages/core`) both need resolution
 * that is not restricted to runes modules, unlike `resolveRunesModuleSpecifier` — and
-* because `resolveComponentPath` (`packages/cli/src/providers/source/resolve.ts`), which
+* because component resolution (`packages/cli/src/providers/source/resolve.ts`), which
 * drives transitive `<head>`/heading resolution, delegates its alias/`$lib`/relative
 * mapping here too, rather than duplicating it. This is the single site for every
 * repo-local specifier resolution in the repo.
 */
 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;
 		if (entry.replacement.startsWith("/") || /^[A-Za-z]:\//.test(entry.replacement)) return void 0;
-		path = entry.replacement + spec.slice(entry.find.length);
+		path = entry.replacement + spec.slice(entry.find.length) + (entry.suffix ?? "");
 	}
-	return normalizePosix(path);
+	const normalized = normalizePosix(path);
+	if (!escapesRoot(normalized)) return normalized;
+	return aliases.some((a) => {
+		const named = a.root ?? a.replacement;
+		const dir = named === null ? "" : normalizePosix(named);
+		return escapesRoot(dir) && (normalized === dir || normalized.startsWith(`${dir}/`));
+	}) ? normalized : void 0;
 }
 /**
 * Resolve an import specifier to a repo-relative `.svelte.ts`/`.svelte.js` path, or
@@ -4080,7 +5240,7 @@ function resolveRepoLocalPath(spec, importerFile, aliases = DEFAULT_KIT_ALIASES)
 * `aliases` (defaulting to `$lib` → `src/lib` when omitted), so a project's declared
 * `kit.alias`/`kit.files.lib` resolve here exactly as they do at rule time; `./`/`../`
 * resolve against the importing file's directory; bare packages, unmatched aliases, and
-* a relative specifier whose `..` segments escape the repo root are skipped. An
+* a path above the project root outside every `kit.alias` directory are skipped. An
 * extensionless `…/x.svelte` specifier canonicalises to `….svelte.ts` (security/shared-state-import also
 * tries the `.js` sibling when matching).
 */
@@ -4115,8 +5275,8 @@ function libServerRoot(aliases) {
 * an equivalent relative path, resolving to exactly that directory — importing the
 * index file rather than a named submodule) is exempt too. A specifier that
 * resolves to undefined — a bare package, an alias that can't map to a repo path, or
-* a relative specifier whose `..` segments escape the repo root (see
-* `normalizePosix`) — is conservatively NOT local state: we can't see that file, so
+* a relative specifier whose `..` segments escape the project root (outside every
+* `kit.alias` directory, see `resolveRepoLocalPath`) — is conservatively NOT local state: we can't see that file, so
 * we don't flag writes to it. Installed packages (drizzle, redis, @vercel/kv, …) are
 * excluded: `.set()`/`.update()` on those is persistence, not shared-module-state
 * mutation. When the `$lib` entry is opaque (`libServerRoot` returns undefined — an unreadable
@@ -4125,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);
@@ -4147,15 +5303,62 @@ const IN_MEMORY_CTORS = /* @__PURE__ */ new Set([
 	"WeakMap",
 	"WeakSet"
 ]);
-/** Whether an initializer positively identifies an in-memory container. */
-function isInMemoryInit(init) {
+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. 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, fns = /* @__PURE__ */ new Set()) {
 	if (!init) return false;
-	if (init.type === "ObjectExpression" || init.type === "ArrayExpression") return true;
+	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, 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, or `new Map`/`Set`/`WeakMap`/`WeakSet`. Used to arbitrate a `.set()` call on
+* 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
 * hand-rolled store from a database client.
 *
@@ -4167,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;
 }
@@ -4187,6 +5395,7 @@ function parseKitModuleFacts(source, filename, aliases) {
 	const importedStateWrites = [];
 	const importedStateWritesOutsideHandlers = [];
 	const pendingServerStoreWrites = [];
+	const storeWriteTargets = [];
 	const runesModuleImports = [];
 	const lifecycleCalls = [];
 	const browserGlobalRefs = [];
@@ -4204,6 +5413,12 @@ function parseKitModuleFacts(source, filename, aliases) {
 	const line = (start) => Math.max(0, lineOf(wrapped, start) - 1);
 	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 : "";
@@ -4212,6 +5427,7 @@ function parseKitModuleFacts(source, filename, aliases) {
 			if (s?.importKind === "type" || s?.local?.type !== "Identifier") continue;
 			names.push(s.local.name);
 			importedSpecifiers.set(s.local.name, spec);
+			if (s.type === "ImportNamespaceSpecifier") namespaceImports.add(s.local.name);
 			importedNames.set(s.local.name, s.type === "ImportSpecifier" && s.imported?.type === "Identifier" ? s.imported.name : s.local.name);
 		}
 		if (names.length === 0) continue;
@@ -4234,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)]);
@@ -4266,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
@@ -4309,23 +5527,26 @@ 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;
-			if (method === "set" || method === "update") {
+			const nsFunction = n.callee.object?.type === "Identifier" && namespaceImports.has(n.callee.object.name);
+			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")) {
@@ -4346,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,
@@ -4377,17 +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) } } : {},
+		...!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
 	};
@@ -5609,8 +6865,8 @@ function isRouteEntry(path) {
 /** The route entries this component imports, with the line each import sits on. */
 function routeEntryImports(c, ctx) {
 	const out = [];
-	for (const { source, line, type } of c.importSpans ?? []) {
-		if (type) continue;
+	for (const { source, line, type, named } of c.importSpans ?? []) {
+		if (type || named) continue;
 		const target = resolveRepoLocalPath(source, c.file, ctx.project.kitAliases);
 		if (target !== void 0 && isRouteEntry(target)) out.push({
 			line,
@@ -5859,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",
@@ -5875,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
@@ -5956,223 +7212,6 @@ const performanceIframeLoading = componentRule({
 	}))
 });
 //#endregion
-//#region src/rules/a11y/aria-data.ts
-/**
-* ARIA names `aria-query@5.3.2` does not carry. It is not the clean ARIA 1.2 snapshot it looks
-* like — it holds 1.2's 48 attributes plus three 1.3 additions — so the gap is patched by name
-* rather than by version. Every entry here is defined in the ARIA 1.3 editor's draft, which is
-* what makes reporting it as an unknown name wrong — how far implementations have got is a
-* separate question this rule does not ask. Re-check this list whenever the aria-query dependency
-* moves.
-*/
-const ARIA_1_3_ROLES = /* @__PURE__ */ new Set([
-	"comment",
-	"image",
-	"sectionheader",
-	"sectionfooter",
-	"suggestion"
-]);
-const ARIA_1_3_ATTRIBUTES = /* @__PURE__ */ new Set(["aria-colindextext", "aria-rowindextext"]);
-/**
-* Roles whose `requiredProps` row in aria-query is stale. Neither ARIA 1.2 nor the 1.3 editor's
-* draft lists required states or properties for these — the 1.3 draft re-lists inherited
-* requirements where they apply (`menuitemradio` → `aria-checked`), so the absence is deliberate
-* rather than an inheritance the table left implicit. Without this, idiomatic APG listbox and
-* tree markup is flagged.
-*/
-const NO_REQUIRED_PROPS = /* @__PURE__ */ new Set(["option", "treeitem"]);
-function isKnownRole(role) {
-	return ARIA_1_3_ROLES.has(role) || roles.has(role);
-}
-function isAbstractRole(role) {
-	return roles.get(role)?.abstract === true;
-}
-/** A concrete (non-abstract) role is the one a user agent resolves a role token list to. */
-function isConcreteRole(role) {
-	return isKnownRole(role) && !isAbstractRole(role);
-}
-/**
-* The role a user agent applies: the first token naming a concrete role, or undefined when none
-* does. Shared so the role rules cannot disagree about what a fallback list means.
-*/
-function resolveRole(tokens) {
-	return tokens.find(isConcreteRole);
-}
-function isKnownAriaAttribute(name) {
-	return ARIA_1_3_ATTRIBUTES.has(name) || aria.has(name);
-}
-function requiredAriaProps(role) {
-	if (NO_REQUIRED_PROPS.has(role)) return [];
-	const def = roles.get(role);
-	return def ? Object.keys(def.requiredProps) : [];
-}
-function ariaValueKind(name) {
-	const def = aria.get(name);
-	if (!def) return void 0;
-	return {
-		type: def.type,
-		...def.values ? { values: def.values.map(String) } : {}
-	};
-}
-//#endregion
-//#region src/a11y.ts
-/**
-* Branch-aware occurrence fold (design "Control-flow semantics"): within a branch
-* occurrences sum, across the arms of one exclusive block the arm with the most
-* occurrences wins (tie → lowest branch index) and ITS occurrences are the group's
-* representatives — so a caller's count is always `list.length`, with a location per
-* representative. `{#each}`/`{#snippet}` occurrences render 0..N times and drop out.
-* The max is per key: there is no scalar total to maximize.
-*/
-function foldOccurrences(nodes) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const node of nodes) {
-		if (node.repeatable) continue;
-		const list = byKey.get(node.key);
-		if (list) list.push(node);
-		else byKey.set(node.key, [node]);
-	}
-	const folded = /* @__PURE__ */ new Map();
-	for (const [key, list] of byKey) folded.set(key, foldAt(list, 0));
-	return folded;
-}
-function foldAt(nodes, depth) {
-	const unconditional = [];
-	const groups = /* @__PURE__ */ new Map();
-	for (const node of nodes) {
-		const step = node.path[depth];
-		if (!step) {
-			unconditional.push(node);
-			continue;
-		}
-		let branches = groups.get(step.group);
-		if (!branches) groups.set(step.group, branches = /* @__PURE__ */ new Map());
-		const list = branches.get(step.branch);
-		if (list) list.push(node);
-		else branches.set(step.branch, [node]);
-	}
-	const representatives = [...unconditional];
-	for (const branches of groups.values()) {
-		let best = [];
-		let bestBranch = Number.POSITIVE_INFINITY;
-		for (const [branch, list] of branches) {
-			const arm = foldAt(list, depth + 1);
-			if (arm.length > best.length || arm.length === best.length && branch < bestBranch) {
-				best = arm;
-				bestBranch = branch;
-			}
-		}
-		representatives.push(...best);
-	}
-	return representatives;
-}
-/**
-* Decode a fragment identifier the way navigation does before matching an element id
-* (`href="#caf%C3%A9"` targets `id="café"`). Malformed escapes are kept verbatim —
-* the browser would also fail to decode them, so the raw text is the comparable form.
-*/
-function decodeFragmentId(fragment) {
-	try {
-		return decodeURIComponent(fragment);
-	} catch {
-		return fragment;
-	}
-}
-/** Whitespace-split tokens of a (possibly undefined) literal attribute value. */
-function splitTokens(value) {
-	return value ? value.trim().split(/\s+/).filter(Boolean) : [];
-}
-/** Explicit `role` values that map to the landmark kinds the route rules inspect. */
-const LANDMARK_ROLES = /* @__PURE__ */ new Set([
-	"main",
-	"banner",
-	"contentinfo",
-	"complementary"
-]);
-/** Sectioning content (HTML-AAM): a `<header>`/`<footer>` below one of these is not a landmark. */
-const SECTIONING_TAGS = /* @__PURE__ */ new Set([
-	"article",
-	"aside",
-	"main",
-	"nav",
-	"section"
-]);
-/**
-* Tags whose landmark-ness depends on sectioning ancestry. A provider that cannot see ancestry
-* (the per-file AST walk) uses this same set to mark the deferral (topLevel) — reading it from
-* here keeps the deferral set from drifting when the policy widens.
-*/
-const ANCESTRY_DEPENDENT_TAGS = /* @__PURE__ */ new Set(["header", "footer"]);
-/** Attributes that give an element the accessible name the `<aside>` landmark decision reads. */
-const NAMING_ATTRS$1 = ["aria-label", "aria-labelledby"];
-/**
-* HTML-AAM: an `<aside>` scoped to `body` or `main` is a `complementary` landmark; scoped to
-* sectioning content it is one only when it has an accessible name. `main` is deliberately absent
-* — it is a scope in which an `aside` *is* a landmark, unlike the sectioning set that decides
-* `<header>`/`<footer>`.
-*/
-const ASIDE_DEMOTING_TAGS = /* @__PURE__ */ new Set([
-	"article",
-	"aside",
-	"nav",
-	"section"
-]);
-/**
-* The landmark kind an element contributes ('main'|'banner'|'contentinfo'|'complementary'), or
-* undefined. The one home for the decision both providers apply — the source AST walk and the
-* rendered HTML walk each feed it their own tree's context. ARIA fallback role lists resolve to
-* the first token naming a concrete role (resolveRole).
-*/
-function resolveLandmark(input) {
-	const { tag, roleTokens, named, insideSectioning, insideAsideDemoting } = input;
-	if (roleTokens !== void 0) {
-		const role = resolveRole(roleTokens);
-		return role && LANDMARK_ROLES.has(role) ? role : void 0;
-	}
-	if (tag === "main") return "main";
-	if (tag !== void 0 && ANCESTRY_DEPENDENT_TAGS.has(tag)) return insideSectioning ? void 0 : tag === "header" ? "banner" : "contentinfo";
-	if (tag === "aside") return !insideAsideDemoting || named ? "complementary" : void 0;
-}
-/**
-* Attributes whose (whitespace-tokenized) values reference element ids: the ARIA id-reference and
-* id-reference-list properties, and HTML's own (`for`, `list`, `headers`, `form`, the popover and
-* command targets). `href="#…"` is handled separately — its value is a URL, not a token list.
-*/
-const IDREF_ATTRS = [
-	"for",
-	"list",
-	"headers",
-	"form",
-	"popovertarget",
-	"commandfor",
-	"aria-labelledby",
-	"aria-describedby",
-	"aria-controls",
-	"aria-activedescendant",
-	"aria-owns",
-	"aria-details",
-	"aria-errormessage",
-	"aria-flowto"
-];
-/**
-* Whether a decoded URL fragment is HTML's "top of the document" indicator: `#top` (ASCII
-* case-insensitive) scrolls to the top when no element has that id, so it is never a missing
-* reference. Compare AFTER percent-decoding — `#%74op` navigates identically to `#top`.
-*/
-function isTopFragment(id) {
-	return id.toLowerCase() === "top";
-}
-/**
-* A fragment with its text directive removed. Everything from the first `:~:` on is user-agent
-* instructions for finding text and names no element, while anything before it is still an
-* ordinary element fragment — `#section:~:text=hi` targets `id="section"`, `#:~:text=hi` targets
-* nothing. Returns an empty string when the fragment is a directive and nothing else.
-*/
-function stripTextDirective(fragment) {
-	const i = fragment.indexOf(":~:");
-	return i === -1 ? fragment : fragment.slice(0, i);
-}
-//#endregion
 //#region src/rules/a11y/invalid-role.ts
 const a11yInvalidRole = componentRule({
 	id: "a11y/invalid-role",
@@ -6765,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
 *
@@ -6872,7 +7911,7 @@ const ELEMENT_FACT_OVERRIDES = {
 };
 /**
 * The role(s) an `AriaElementFact` may have. Explicit first: a literal role's first concrete token
-* (`resolveRole`); an expression role, or a spread with no literal role, makes the role unknowable
+* (`resolveRole`); an expression role, or a spread or `use:` action with no literal role, makes the role unknowable
 * and yields `undefined`. Otherwise the element's implicit role — never one role but the set of
 * candidates the dataset's conditional outcomes leave open, since the selectors that decide between
 * them are not evaluated (design 2026-08-19-aria-role-table-rules, "Which role an element has").
@@ -6887,7 +7926,7 @@ function roleCandidates(e) {
 			namingProhibited: false
 		} : void 0;
 	}
-	if (e.hasSpread) return void 0;
+	if (e.hasSpread || e.hasAction) return void 0;
 	const el = Object.hasOwn(HTML_SPEC.elements, e.tag) ? HTML_SPEC.elements[e.tag] : void 0;
 	if (!el) return void 0;
 	const aria = (Object.hasOwn(ELEMENT_FACT_OVERRIDES, e.tag) ? ELEMENT_FACT_OVERRIDES[e.tag] : void 0) ?? el.aria;
@@ -7454,7 +8493,12 @@ function surplusRule(spec) {
 					first ??= reps[0];
 					for (let i = 1; i < reps.length; i++) {
 						surplus = true;
-						out.push(result(route.route, PENALIZED$1, reps[i], spec.message(key, i, reps.length, reps[0])));
+						const finding = result(route.route, PENALIZED$1, reps[i], spec.message(key, i, reps.length, reps[0]));
+						const recommendation = spec.recommendationFor?.(reps[i], reps[0]);
+						out.push(recommendation ? {
+							...finding,
+							recommendation
+						} : finding);
 					}
 				}
 				if (first && !surplus) out.push(result(route.route, PASS, {
@@ -7632,6 +8676,7 @@ const a11yIdDuplication = surplusRule({
 	recommendation: "Every id in a route should be unique.",
 	map: (route) => Object.entries(route.ids).sort(([, a], [, b]) => a[0].file.localeCompare(b[0].file) || a[0].line - b[0].line),
 	message: (id, _i, _n, first) => first.file === "src/app.html" ? `Duplicate id "${id}" — also defined by the src/app.html shell (line ${first.line})` : `Duplicate id "${id}"`,
+	recommendationFor: (rep, first) => first.file === "src/app.html" || first.line === 0 ? void 0 : rep.file === first.file && rep.line === first.line ? "This id is hardcoded in a component rendered more than once on this route. Generate it per instance with $props.id() (Svelte 5.20+): `const uid = $props.id();`, then `id=\"{uid}-name\"`." : "Rename one of them. Separate {#if} blocks are treated as able to render together; if these never render at the same time, make them branches of one {#if}…{:else}.",
 	passMessage: "No duplicate ids"
 });
 //#endregion
@@ -8152,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
@@ -8299,4 +9365,4 @@ function formatMarkdownReport(results, config, meta) {
 	return lines.join("\n");
 }
 //#endregion
-export { SECTIONING_TAGS as $, formatFailedRuleWarning as $n, valueFromNodes as $t, a11yAbbrTitle as A, seoDescriptionLength as An, collectDerivedGuardBindings as At, a11yUseList as B, seoOgUrl as Bn, unwrapTs as Bt, a11yDisallowedElement as C, seoHeadingLevelSkip as Cn, summarize as Cr, parseKitModuleFacts as Ct, a11yDeprecatedElement as D, seoHreflang as Dn, defaultConfig as Dr, addBoundNames as Dt, a11yDeprecatedAttr as E, seoSingleH1 as En, CATEGORIES as Er, WALK_IGNORED_KEYS as Et, isInteractiveContainer as F, seoJsonLdRelativeUrl as Fn, matchLifecycleCall as Ft, a11yInvalidAriaValue as G, isPlainObject as Gn, attrText as Gt, a11yAccessibleName as H, seoTwitterCard as Hn, walkEvalScope as Ht, isInteractiveElement as I, seoJsonLdDeprecatedType as In, parseModuleProgram as It, a11yInvalidRole as J, validateRuleSetting as Jn, attrValueOf as Jt, a11yRequiredAriaProps as K, resolveRuleOptions as Kn, attrTextOf as Kt, literalTabindexValue as L, seoJsonLdValidity as Ln, rootObjectName as Lt, a11yNoAutofocus as M, seoJsonLdRequiredProps as Mn, collectProgramBindings as Mt, a11yNoAccesskey as N, seoJsonLdPlaceholder as Nn, collectSuppressions as Nt, HTML_SPEC as O, seoImageAlt as On, defaultProject as Or, collectBrowserGlobalRefs as Ot, a11yPositiveTabindex as P, seoJsonLdDateFormat as Pn, collectSvelteLifecycleImports as Pt, NAMING_ATTRS$1 as Q, compileOverrides as Qn, textFromNodes as Qt, a11yRequireDatetime as R, seoSitemapInRobots as Rn, scopeIntroducedNames as Rt, a11yPermittedContents as S, seoSsrDisabled as Sn, hasFailureAtOrAbove as Sr, parseInMemoryExports as St, a11yDisallowedAriaProps as T, seoDuplicateTitle as Tn, isPenalized as Tr, isRootRelativePath as Tt, a11yAriaHiddenFocus as U, seoIndexability as Un, walkScoped as Ut, a11yLabelHasControl as V, seoOgDescription as Vn, walkEstree as Vt, a11yInteractiveNesting as W, performancePreconnect as Wn, CHILD_NODE_KEYS as Wt, ASIDE_DEMOTING_TAGS as X, applyOverrides as Xn, lineOf as Xt, ANCESTRY_DEPENDENT_TAGS as Y, SEARCH_RESULT_RULES as Yn, findAttr as Yt, IDREF_ATTRS as Z, applyRuleSeverities as Zn, parseSvelte as Zt, a11yIdDuplication as _, correctnessUnmutatedState as _n, seoCanonicalUrl as _r, architectureReservedDirectoryNames as _t, formatJsonReport as a, securityJavascriptUrl as an, performanceLcpImage as ar, stripTextDirective as at, a11yDoctype as b, correctnessEachIndexKey as bn, classify as br, architecturePrivateScopeImport as bt, formatGithubReport as c, correctnessServerBrowserGlobal as cn, performanceResponsiveImage as cr, performanceStateRaw as ct, ruleMetaById as d, correctnessOrphanEffect as dn, seoHtmlLang as dr, performanceMinifyDisabled as dt, architecturePropCount as en, selectRules as er, decodeFragmentId as et, severityToSarifLevel as f, correctnessAutoplayMuted as fn, seoSitemapXml as fr, performanceNamespaceImport as ft, a11yNoMissingIdRef as g, correctnessPropMutation as gn, seoOgImage as gr, architectureReservedNamePlacement as gt, a11yUnverifiedIdRef as h, correctnessStalePropDerivation as hn, seoOgTitle as hr, architectureRouteComponentImport as ht, buildJsonReport as i, securityHandlerStateWrite as in, performanceRenderBlockingScript as ir, splitTokens as it, a11yNoDuplicateDt as j, seoTitleLength as jn, collectNamedImportAliases as jt, a11yPatternTitle as k, seoCharset as kn, defineConfig as kr, collectBrowserGuardImports as kt, SEVERITY_RANK as l, correctnessBasePathNavigation as ln, performanceImageLoadingHint as lr, performanceSequentialAwaits as lt, explainRule as m, correctnessNonreactiveBuiltinState as mn, seoJsonLd as mr, architectureDocLinkTarget as mt, mdEscape as n, securitySharedStateImport as nn, withFailedRulesOff as nr, isTopFragment as nt, computeHealth as o, securityRawHtml as on, performanceFontPreloadCrossorigin as or, resolveRole as ot, allRules as p, correctnessCheckableBindValue as pn, seoRobotsTxt as pr, performanceHeavyImport as pt, a11yUnknownAriaAttribute as q, shouldSkipRangeCheck as qn, attrValue as qt, terminalSafe as r, securityServerModuleState as rn, withIndexableOff as rr, resolveLandmark as rt, computeScore as s, correctnessInstanceBrowserGlobal as sn, performancePreloadMissingAs as sr, performanceIframeLoading as st, formatMarkdownReport as t, architectureComponentSize as tn, settingSeverity as tr, foldOccurrences as tt, messageText as u, correctnessOrphanLifecycle as un, performanceImageDimensions as ur, performanceLoadWaterfall as ut, a11yTopLevelLandmark as v, correctnessEffectAsOnMount as vn, seoDescriptionPresence as vr, architectureDirectoryNaming as vt, a11yDeprecatedAria as w, seoDuplicateDescription as wn, docsUrlFor as wr, resolveRepoLocalPath as wt, a11yRequiredElement as x, correctnessEachKey as xn, effectiveSeverity as xr, collectTopLevelBindings as xt, a11yDuplicateLandmark as y, correctnessEffectAsDerived as yn, seoTitlePresence as yr, architectureUnitEntryFile as yt, a11yPlaceholderLabelOption as z, seoViewport as zn, unwrapExport 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 };