@svelte-vitals/core 0.55.1 → 0.55.3

package/dist/internal.js

@@ -1,51 +1,40 @@
-import { $ as SECTIONING_TAGS, $n as formatFailedRuleWarning, $t as valueFromNodes, A as a11yAbbrTitle, An as seoDescriptionLength, At as collectDerivedGuardBindings, B as a11yUseList, Bn as seoOgUrl, Bt as unwrapTs, C as a11yDisallowedElement, Cn as seoHeadingLevelSkip, Cr as summarize, Ct as parseKitModuleFacts, D as a11yDeprecatedElement, Dn as seoHreflang, Dr as defaultConfig, Dt as addBoundNames, E as a11yDeprecatedAttr, En as seoSingleH1, Et as WALK_IGNORED_KEYS, F as isInteractiveContainer, Fn as seoJsonLdRelativeUrl, Ft as matchLifecycleCall, G as a11yInvalidAriaValue, Gn as isPlainObject, Gt as attrText, H as a11yAccessibleName, Hn as seoTwitterCard, Ht as walkEvalScope, I as isInteractiveElement, In as seoJsonLdDeprecatedType, It as parseModuleProgram, J as a11yInvalidRole, Jn as validateRuleSetting, Jt as attrValueOf, K as a11yRequiredAriaProps, Kn as resolveRuleOptions, Kt as attrTextOf, L as literalTabindexValue, Ln as seoJsonLdValidity, Lt as rootObjectName, M as a11yNoAutofocus, Mn as seoJsonLdRequiredProps, Mt as collectProgramBindings, N as a11yNoAccesskey, Nn as seoJsonLdPlaceholder, Nt as collectSuppressions, O as HTML_SPEC, On as seoImageAlt, Or as defaultProject, Ot as collectBrowserGlobalRefs, P as a11yPositiveTabindex, Pn as seoJsonLdDateFormat, Pt as collectSvelteLifecycleImports, Q as NAMING_ATTRS, Qn as compileOverrides, Qt as textFromNodes, R as a11yRequireDatetime, Rn as seoSitemapInRobots, Rt as scopeIntroducedNames, S as a11yPermittedContents, Sn as seoSsrDisabled, Sr as hasFailureAtOrAbove, St as parseInMemoryExports, T as a11yDisallowedAriaProps, Tn as seoDuplicateTitle, Tr as isPenalized, Tt as isRootRelativePath, U as a11yAriaHiddenFocus, Un as seoIndexability, Ut as walkScoped, V as a11yLabelHasControl, Vn as seoOgDescription, Vt as walkEstree, W as a11yInteractiveNesting, Wn as performancePreconnect, Wt as CHILD_NODE_KEYS, X as ASIDE_DEMOTING_TAGS, Xn as applyOverrides, Xt as lineOf, Y as ANCESTRY_DEPENDENT_TAGS, Yn as SEARCH_RESULT_RULES, Yt as findAttr, Z as IDREF_ATTRS, Zn as applyRuleSeverities, Zt as parseSvelte, _ as a11yIdDuplication, _n as correctnessUnmutatedState, _r as seoCanonicalUrl, _t as architectureReservedDirectoryNames, a as formatJsonReport, an as securityJavascriptUrl, ar as performanceLcpImage, at as stripTextDirective, b as a11yDoctype, bn as correctnessEachIndexKey, br as classify, bt as architecturePrivateScopeImport, c as formatGithubReport, cn as correctnessServerBrowserGlobal, cr as performanceResponsiveImage, ct as performanceStateRaw, d as ruleMetaById, dn as correctnessOrphanEffect, dr as seoHtmlLang, dt as performanceMinifyDisabled, en as architecturePropCount, er as selectRules, et as decodeFragmentId, f as severityToSarifLevel, fn as correctnessAutoplayMuted, fr as seoSitemapXml, ft as performanceNamespaceImport, g as a11yNoMissingIdRef, gn as correctnessPropMutation, gr as seoOgImage, gt as architectureReservedNamePlacement, h as a11yUnverifiedIdRef, hn as correctnessStalePropDerivation, hr as seoOgTitle, ht as architectureRouteComponentImport, i as buildJsonReport, in as securityHandlerStateWrite, ir as performanceRenderBlockingScript, it as splitTokens, j as a11yNoDuplicateDt, jn as seoTitleLength, jt as collectNamedImportAliases, k as a11yPatternTitle, kn as seoCharset, kt as collectBrowserGuardImports, l as SEVERITY_RANK, ln as correctnessBasePathNavigation, lr as performanceImageLoadingHint, lt as performanceSequentialAwaits, m as explainRule, mn as correctnessNonreactiveBuiltinState, mr as seoJsonLd, mt as architectureDocLinkTarget, n as mdEscape, nn as securitySharedStateImport, nr as withFailedRulesOff, nt as isTopFragment, o as computeHealth, on as securityRawHtml, or as performanceFontPreloadCrossorigin, ot as resolveRole, p as allRules, pn as correctnessCheckableBindValue, pr as seoRobotsTxt, pt as performanceHeavyImport, q as a11yUnknownAriaAttribute, qn as shouldSkipRangeCheck, qt as attrValue, r as terminalSafe, rn as securityServerModuleState, rr as withIndexableOff, rt as resolveLandmark, s as computeScore, sn as correctnessInstanceBrowserGlobal, sr as performancePreloadMissingAs, st as performanceIframeLoading, t as formatMarkdownReport, tn as architectureComponentSize, tr as settingSeverity, tt as foldOccurrences, u as messageText, un as correctnessOrphanLifecycle, ur as performanceImageDimensions, ut as performanceLoadWaterfall, v as a11yTopLevelLandmark, vn as correctnessEffectAsOnMount, vr as seoDescriptionPresence, vt as architectureDirectoryNaming, w as a11yDeprecatedAria, wn as seoDuplicateDescription, wr as docsUrlFor, wt as resolveRepoLocalPath, x as a11yRequiredElement, xn as correctnessEachKey, xr as effectiveSeverity, xt as collectTopLevelBindings, y as a11yDuplicateLandmark, yn as correctnessEffectAsDerived, yr as seoTitlePresence, yt as architectureUnitEntryFile, z as a11yPlaceholderLabelOption, zn as seoViewport, zt as unwrapExport } from "./markdown-BOH3FPQl.js";
-//#region src/head.ts
-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());
+import { $ as performanceLoadWaterfall, $n as shouldSkipRangeCheck, $t as securityJavascriptUrl, A as a11yPatternTitle, An as splitTokens, Ar as seoTitlePresence, At as parseModuleProgram, B as a11yPlaceholderLabelOption, Bn as seoJsonLdDateFormat, Bt as attrTextOf, C as a11yPermittedContents, Cn as IDREF_ATTRS, Cr as seoCanonicalUrl, Ct as collectBrowserGuardImports, D as a11yDeprecatedAttr, Dn as foldOccurrences, Dr as layoutNeverRenders, Dt as collectSuppressions, E as a11yDisallowedAriaProps, En as decodeFragmentId, Er as seoDescriptionPresence, Et as collectProgramBindings, F as a11yPositiveTabindex, Fn as seoCharset, Fr as docsUrlFor, Ft as walkEstree, G as a11yInteractiveNesting, Gn as seoViewport, Gt as parseSvelte, H as a11yLabelHasControl, Hn as seoJsonLdDeprecatedType, Ht as attrValueOf, I as isInteractiveContainer, In as seoDescriptionLength, Ir as isPenalized, It as walkEvalScope, J as a11yUnknownAriaAttribute, Jn as seoTwitterCard, Jt as architecturePropCount, K as a11yInvalidAriaValue, Kn as seoOgUrl, Kt as textFromNodes, L as isInteractiveElement, Ln as seoTitleLength, Lt as walkScoped, M as a11yNoDuplicateDt, Mn as resolveRole, Mr as effectiveSeverity, Mt as scopeIntroducedNames, N as a11yNoAutofocus, Nn as seoHreflang, Nr as hasFailureAtOrAbove, Nt as unwrapExport, O as a11yDeprecatedElement, On as isTopFragment, Or as pageRendersOnlyWhenBuilding, Ot as collectSvelteLifecycleImports, P as a11yNoAccesskey, Pn as seoImageAlt, Pr as summarize, Pt as unwrapTs, Q as performanceSequentialAwaits, Qn as resolveRuleOptions, Qt as securityHandlerStateWrite, R as literalTabindexValue, Rn as seoJsonLdRequiredProps, Rr as defaultConfig, Rt as CHILD_NODE_KEYS, S as a11yRequiredElement, Sn as ASIDE_DEMOTING_TAGS, Sr as seoOgImage, St as collectBrowserGlobalRefs, T as a11yDeprecatedAria, Tn as SECTIONING_TAGS, Tr as isClassicScriptType, Tt as collectNamedImportAliases, U as a11yAccessibleName, Un as seoJsonLdValidity, Ut as findAttr, V as a11yUseList, Vn as seoJsonLdRelativeUrl, Vt as attrValue, W as a11yAriaHiddenFocus, Wn as seoSitemapInRobots, Wt as lineOf, X as performanceIframeLoading, Xn as performancePreconnect, Xt as securitySharedStateImport, Y as a11yInvalidRole, Yn as seoIndexability, Yt as architectureComponentSize, Z as performanceStateRaw, Zn as isPlainObject, Zt as securityServerModuleState, _ as a11yNoMissingIdRef, _n as seoHeadingLevelSkip, _r as seoHtmlLang, _t as parseKitModuleFacts, a as formatJsonReport, an as correctnessOrphanEffect, ar as formatFailedRuleWarning, at as architectureReservedNamePlacement, b as a11yDuplicateLandmark, bn as seoSingleH1, br as seoJsonLd, bt as WALK_IGNORED_KEYS, c as computeScore, cn as correctnessNonreactiveBuiltinState, cr as withFailedRulesOff, ct as architectureUnitEntryFile, d as messageText, dn as correctnessUnmutatedState, dr as performanceLcpImage, dt as collectFalseExports, en as securityRawHtml, er as validateRuleSetting, et as performanceMinifyDisabled, f as ruleMetaById, fn as correctnessEffectAsOnMount, fr as performanceFontPreloadCrossorigin, ft as collectTopLevelBindings, g as a11yUnverifiedIdRef, gn as seoSsrDisabled, gr as performanceImageDimensions, gt as parseInMemoryExports, h as explainRule, hn as correctnessEachKey, hr as performanceImageLoadingHint, ht as parseFalseExports, i as buildJsonReport, in as correctnessOrphanLifecycle, ir as compileOverrides, it as architectureRouteComponentImport, j as a11yAbbrTitle, jn as stripTextDirective, jr as classify, jt as rootObjectName, k as HTML_SPEC, kn as resolveLandmark, kr as routeNeverSsr, kt as matchLifecycleCall, l as formatGithubReport, ln as correctnessStalePropDerivation, lr as withIndexableOff, lt as architecturePrivateScopeImport, m as allRules, mn as correctnessEachIndexKey, mr as performanceResponsiveImage, mt as parseExitFactoryExports, n as mdEscape, nn as correctnessServerBrowserGlobal, nr as applyOverrides, nt as performanceHeavyImport, o as formatJsonReportChunks, on as correctnessAutoplayMuted, or as selectRules, ot as architectureReservedDirectoryNames, p as severityToSarifLevel, pn as correctnessEffectAsDerived, pr as performancePreloadMissingAs, pt as parseClientExports, q as a11yRequiredAriaProps, qn as seoOgDescription, qt as valueFromNodes, r as terminalSafe, rn as correctnessBasePathNavigation, rr as applyRuleSeverities, rt as architectureDocLinkTarget, s as computeHealth, sn as correctnessCheckableBindValue, sr as settingSeverity, st as architectureDirectoryNaming, t as formatMarkdownReport, tn as correctnessInstanceBrowserGlobal, tr as SEARCH_RESULT_RULES, tt as performanceNamespaceImport, u as SEVERITY_RANK, un as correctnessPropMutation, ur as performanceRenderBlockingScript, ut as DEFAULT_KIT_ALIASES, v as a11yIdDuplication, vn as seoDuplicateDescription, vr as seoSitemapXml, vt as resolveRepoLocalPath, w as a11yDisallowedElement, wn as NAMING_ATTRS, wr as hasRel, wt as collectDerivedGuardBindings, x as a11yDoctype, xn as ANCESTRY_DEPENDENT_TAGS, xr as seoOgTitle, xt as addBoundNames, y as a11yTopLevelLandmark, yn as seoDuplicateTitle, yr as seoRobotsTxt, yt as isRootRelativePath, z as a11yRequireDatetime, zn as seoJsonLdPlaceholder, zr as defaultProject, zt as attrText } from "./markdown-CsQNXeWj.js";
+//#region src/images.ts
+/** A `.svg` path (query and fragment ignored) or an inline `data:image/svg+xml` URI. */
+function isSvgSrc(src) {
+	return /^data:image\/svg\+xml[;,]/i.test(src) || /\.svg$/i.test(src.split(/[?#]/, 1)[0]);
 }
 //#endregion
 //#region src/component-parse.ts
 const KNOWN_TAGS = new Set(Object.keys(HTML_SPEC.elements).map((k) => k.replace(/^svg:/, "").toLowerCase()));
-/** Whether `expr` is a length-only list constructor: `Array(n)` / `new Array(n)` (single argument = length semantics) or `Array.from({ length: n }, …)`. */
+/**
+* Whether `expr` is a length-only list constructor: `Array(n)` / `new Array(n)` (single argument =
+* length semantics), `Array.from({ length: n }, …)`, or `Array.from(<any of these>, …)`, optionally
+* followed by `.fill(x)` (every item the same value) or `.keys()` (the indices themselves).
+*/
 function isLengthOnlyArrayCall(expr) {
 	const e = unwrapTs(expr);
 	if (!e) return false;
+	if (e.type === "CallExpression" && e.callee?.type === "MemberExpression" && !e.callee.computed && e.callee.object.type !== "Super" && e.callee.property.type === "Identifier" && (e.callee.property.name === "fill" || e.callee.property.name === "keys")) {
+		const receiver = unwrapTs(e.callee.object);
+		if (receiver?.type === "ArrayExpression") return receiver.elements.every((el) => el?.type !== "SpreadElement" || isLengthOnlyArrayCall(el.argument));
+		return isLengthOnlyArrayCall(e.callee.object);
+	}
 	if ((e.type === "CallExpression" || e.type === "NewExpression") && e.callee?.type === "Identifier" && e.callee.name === "Array") return (e.arguments?.length ?? 0) === 1;
-	if (e.type === "CallExpression" && e.callee?.type === "MemberExpression" && !e.callee.computed && e.callee.object?.type === "Identifier" && e.callee.object.name === "Array" && e.callee.property.type === "Identifier" && e.callee.property.name === "from" && e.arguments?.[0]?.type === "ObjectExpression") return (e.arguments[0].properties ?? []).some((p) => p?.type === "Property" && !p.computed && (p.key?.name === "length" || p.key?.value === "length"));
+	if (e.type === "CallExpression" && e.callee?.type === "MemberExpression" && !e.callee.computed && e.callee.object?.type === "Identifier" && e.callee.object.name === "Array" && e.callee.property.type === "Identifier" && e.callee.property.name === "from") {
+		const source = e.arguments?.[0];
+		if (source?.type === "ObjectExpression") return (source.properties ?? []).some(isLengthProperty);
+		return source !== void 0 && source.type !== "SpreadElement" && isLengthOnlyArrayCall(source);
+	}
 	return false;
 }
+function isLengthProperty(p) {
+	return p?.type === "Property" && !p.computed && (p.key?.name === "length" || p.key?.value === "length");
+}
 /**
 * Whether the each expression yields no item identity to key on: a constant
 * inline array literal (fixed length, never reorders), a length-only list
-* (`Array(n)`, `new Array(n)`, `[...Array(n)]`, `Array.from({ length: n })` —
+* (`Array(n)`, `new Array(n)`, `[...Array(n)]`, `Array.from({ length: n })`, `Array(n).fill(x)`, `{ length: n }` —
 * placeholder/skeleton lists), or a spread array whose every element spreads a
 * length-only list. Such blocks are skipped entirely — neither each-key nor
 * each-index-key can give useful advice on them.
@@ -53,6 +42,7 @@ function isLengthOnlyArrayCall(expr) {
 function isIdentityFreeEach(node) {
 	const expr = unwrapTs(node.expression);
 	if (expr.type === "ArrayExpression" && Array.isArray(expr.elements)) return expr.elements.every((el) => el?.type !== "SpreadElement" || isLengthOnlyArrayCall(el.argument));
+	if (expr.type === "ObjectExpression") return expr.properties.length === 1 && isLengthProperty(expr.properties[0]);
 	return isLengthOnlyArrayCall(expr);
 }
 /**
@@ -97,19 +87,194 @@ function isIndexKey(each) {
 	if (typeof each.index !== "string" || each.key == null) return false;
 	return isIndexExpression(each.key, each.index);
 }
+/**
+* TS nodes that wrap value-space code; every other `TS*` node is a type position. Enums,
+* namespaces and parameter properties are left out: Svelte's own TS support rejects them.
+*/
+const TS_VALUE_NODES = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSInstantiationExpression",
+	"TSTypeAssertion"
+]);
+/**
+* Names of `const X = [ … ]` array literals (script top level) that nothing can reorder: every
+* other mention of `X` in the file is a member read, an `{#each X …}`, a `for (… of X)` or a copy into an array literal
+* (`[...X]`). Such a list is the inline
+* literal the each rules already skip, just given a name. Anything else — a mutating call, an
+* assignment through it, passing or spreading `X` — keeps the list keyed. A component's value
+* imports are held to the same uses (`imports`), since the module behind one may be such a list;
+* a module's `export const` is a candidate only with `exported`, because a component's `export`
+* is written by its parent.
+*/
+function collectConstantLists(programs, fragment, opts = {}) {
+	const candidates = /* @__PURE__ */ new Map();
+	const safe = /* @__PURE__ */ new Set();
+	const iterated = opts.imports ? eachListRoots(fragment) : void 0;
+	for (const program of programs) for (const top of program.body ?? []) {
+		if (iterated?.size && top?.type === "ImportDeclaration" && top.importKind !== "type") for (const s of top.specifiers ?? []) {
+			if (s?.importKind === "type" || s?.type === "ImportDefaultSpecifier" || !iterated.has(s?.local?.name)) continue;
+			const imported = s.type === "ImportNamespaceSpecifier" ? "*" : s.imported?.name ?? s.imported?.value;
+			if (typeof imported !== "string") continue;
+			opts.imports.set(s.local.name, {
+				source: String(top.source.value),
+				imported
+			});
+			candidates.set(s.local.name, s.local);
+			safe.add(s.imported);
+		}
+		if (opts.exported && top?.type === "ExportNamedDeclaration" && !top.source) for (const s of top.specifiers ?? []) safe.add(s.local).add(s.exported);
+		const stmt = opts.exported ? unwrapExport(top) : top;
+		if (stmt?.type !== "VariableDeclaration" || stmt.kind !== "const") continue;
+		for (const d of stmt.declarations ?? []) {
+			const init = opts.sets ? setLiteralList(unwrapTs(d?.init)) : unwrapTs(d?.init);
+			if (d?.id?.type === "Identifier" && init?.type === "ArrayExpression") {
+				if (!(init.elements ?? []).some((el) => el?.type === "SpreadElement")) candidates.set(d.id.name, d.id);
+			}
+		}
+	}
+	if (candidates.size === 0) return /* @__PURE__ */ new Set();
+	const aliases = /* @__PURE__ */ new Map();
+	if (opts.exported) for (const program of programs) walkEstree(program, (n) => {
+		if (n.type !== "VariableDeclaration" || n.kind !== "const") return;
+		for (const d of n.declarations ?? []) {
+			const init = unwrapTs(d?.init);
+			const list = (init?.type === "ConditionalExpression" ? [init.consequent, init.alternate] : init?.type === "LogicalExpression" && init.operator !== "&&" ? [init.left, init.right] : [init]).map((b) => unwrapTs(b)).find((b) => b?.type === "Identifier" && candidates.has(b.name));
+			if (d?.id?.type !== "Identifier" || !list || candidates.has(d.id.name)) continue;
+			safe.add(list);
+			aliases.set(d.id.name, list.name);
+			candidates.set(d.id.name, d.id);
+		}
+	});
+	for (const node of candidates.values()) safe.add(node);
+	const namespaces = new Set([...opts.imports ?? []].filter(([, b]) => b.imported === "*").map(([local]) => local));
+	const unsafe = /* @__PURE__ */ new Set();
+	const roots = [...programs, fragment];
+	const listOf = (n) => n?.type === "Identifier" && candidates.has(n.name) ? n.name : void 0;
+	const outerList = listOf;
+	const nsMember = (n) => n?.type === "MemberExpression" && !n.computed && namespaces.has(listOf(n.object)) ? `${n.object.name}.${n.property.name}` : void 0;
+	const outerMember = nsMember;
+	const members = /* @__PURE__ */ new Set();
+	const declared = /* @__PURE__ */ new Set();
+	for (const program of programs) {
+		const imported = /* @__PURE__ */ new Set();
+		for (const top of program.body ?? []) if (top?.type === "ImportDeclaration") for (const s of top.specifiers ?? []) imported.add(s?.local?.name);
+		for (const name of collectProgramBindings(program)) if (!imported.has(name)) declared.add(name);
+	}
+	for (const root of roots) walkScoped(root, (n, shadowed) => {
+		const listOf = (x) => {
+			const name = outerList(x);
+			return name && !shadowed.has(name) ? name : void 0;
+		};
+		const nsMember = (x) => x?.type === "MemberExpression" && listOf(x.object) ? outerMember(x) : void 0;
+		if (n.type === "EachBlock" && (listOf(n.expression) || nsMember(n.expression))) safe.add(n.expression);
+		if (n.type === "ForOfStatement" && (listOf(n.right) || nsMember(n.right))) safe.add(n.right);
+		if (n.type === "ArrayExpression") {
+			for (const el of n.elements ?? []) if (el?.type === "SpreadElement" && (listOf(el.argument) || nsMember(el.argument))) safe.add(el.argument);
+		}
+		if (nsMember(n)) members.add(nsMember(n));
+		if (n.type === "MemberExpression") {
+			const object = n.object ? unwrapTs(n.object) : n.object;
+			if (listOf(object) && !(n.computed && namespaces.has(object.name))) safe.add(object);
+			if (nsMember(object)) safe.add(object);
+			if (!n.computed) safe.add(n.property);
+		}
+		const target = n.type === "AssignmentExpression" ? n.left : n.type === "UpdateExpression" ? n.argument : void 0;
+		let root = target;
+		while (root && (root.type === "MemberExpression" || root.type.startsWith("TS"))) root = root.type === "MemberExpression" ? root.object : root.expression;
+		if (target?.type === "MemberExpression" && listOf(root)) unsafe.add(listOf(root));
+		const called = n.type === "CallExpression" && n.callee?.type === "MemberExpression" ? unwrapTs(n.callee.object) : void 0;
+		const calledList = listOf(called) ?? nsMember(called);
+		if (calledList) {
+			const { computed, property } = n.callee;
+			const method = !computed ? property?.name : property?.type === "Literal" && typeof property.value === "string" ? property.value : void 0;
+			if (computed && method === void 0 || method !== void 0 && MUTATING_METHODS.has(method)) unsafe.add(calledList);
+		}
+		const callee = n.type === "CallExpression" || n.type === "NewExpression" ? rootObjectName(n.callee) : void 0;
+		if (opts.exported && callee !== void 0 && !declared.has(callee) && !shadowed.has(callee)) {
+			for (const arg of n.arguments ?? []) if (listOf(unwrapTs(arg))) safe.add(unwrapTs(arg));
+		}
+		if (n.type === "BindDirective" && listOf(rootObjectNode(n.expression))) unsafe.add(listOf(rootObjectNode(n.expression)));
+		if (n.type === "Property" && !n.computed && !n.shorthand) safe.add(n.key);
+	});
+	for (const root of roots) walkEvalScope(root, (n, shadowed) => {
+		if (n.type.startsWith("TS") && !TS_VALUE_NODES.has(n.type)) return true;
+		const name = listOf(n) ?? nsMember(n);
+		if (name && !safe.has(n) && !shadowed.has(name.split(".")[0])) unsafe.add(name);
+		return false;
+	}, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+	for (const [alias, list] of aliases) if (unsafe.has(alias)) unsafe.add(list);
+	return new Set([...candidates.keys(), ...members].filter((key) => !aliases.has(key) && !unsafe.has(key) && !unsafe.has(key.split(".")[0])));
+}
+/** A component's script `const` lists that nothing in its scripts or template can change. */
+function collectComponentConstantLists(ast, opts = {}) {
+	return collectConstantLists([ast.module?.content, ast.instance?.content].filter(Boolean), ast.fragment ?? ast, opts);
+}
+/** The array literal of `new Set([…])`, or the node itself. */
+function setLiteralList(n) {
+	const arg = n?.type === "NewExpression" && n.callee?.type === "Identifier" && n.callee.name === "Set" ? n.arguments : void 0;
+	return arg?.length === 1 && unwrapTs(arg[0])?.type === "ArrayExpression" ? unwrapTs(arg[0]) : n;
+}
+/**
+* Export names of a module's constant lists — `export const X = [ … ]`, or a local one exported by
+* name — that the module itself never writes (correctness/each-key, correctness/each-index-key).
+*/
+function collectConstantListExports(program) {
+	const lists = collectConstantLists([program], void 0, { exported: true });
+	const out = /* @__PURE__ */ new Set();
+	for (const top of program?.body ?? []) {
+		if (top?.type !== "ExportNamedDeclaration" || top.exportKind === "type") continue;
+		for (const d of top.declaration?.declarations ?? []) if (d?.id?.type === "Identifier" && lists.has(d.id.name)) out.add(d.id.name);
+		for (const s of top.source ? [] : top.specifiers ?? []) if (lists.has(s.local.name)) out.add(s.exported.name ?? s.exported.value);
+	}
+	return out;
+}
+/** The root names `{#each}` blocks iterate: `xs` for both `{#each xs …}` and `{#each xs.ys …}`. */
+function eachListRoots(node, acc = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(node)) {
+		for (const child of node) eachListRoots(child, acc);
+		return acc;
+	}
+	if (!node || typeof node !== "object") return acc;
+	if (node.type === "EachBlock") {
+		const expr = node.expression?.type === "MemberExpression" ? node.expression.object : node.expression;
+		if (expr?.type === "Identifier") acc.add(expr.name);
+	}
+	for (const key of CHILD_NODE_KEYS) if (key in node) eachListRoots(node[key], acc);
+	return acc;
+}
+/** The innermost object of a member chain (`a` for `a.b[c].d`), or the node itself. */
+function rootObjectNode(n) {
+	let cur = n;
+	while (cur?.type === "MemberExpression") cur = cur.object;
+	return cur;
+}
 /** Recursively collect every `{#each}` block in the template (correctness/each-key). */
-function collectEachBlocks(node, source, acc) {
+function collectEachBlocks(node, source, acc, lists, imports) {
 	if (Array.isArray(node)) {
-		for (const child of node) collectEachBlocks(child, source, acc);
+		for (const child of node) collectEachBlocks(child, source, acc, lists, imports);
 		return;
 	}
 	if (!node || typeof node !== "object") return;
-	if (node.type === "EachBlock" && node.context != null && !isIdentityFreeEach(node)) acc.push({
-		hasKey: node.key != null,
-		line: lineOf(source, node.start),
-		...isIndexKey(node) ? { indexKey: true } : {}
-	});
-	for (const key of CHILD_NODE_KEYS) if (key in node) collectEachBlocks(node[key], source, acc);
+	if (node.type === "EachBlock" && node.context != null && !isIdentityFreeEach(node)) {
+		const expr = node.expression;
+		const list = expr?.type === "Identifier" ? expr.name : expr?.type === "MemberExpression" && !expr.computed && expr.object?.type === "Identifier" ? `${expr.object.name}.${expr.property.name}` : void 0;
+		const constant = list !== void 0 && lists.has(list);
+		const [local, member] = list?.split(".") ?? [];
+		const binding = constant ? imports.get(local) : void 0;
+		const indexKey = isIndexKey(node);
+		if (!constant || binding) acc.push({
+			hasKey: node.key != null,
+			line: lineOf(source, node.start),
+			...indexKey ? { indexKey: true } : {},
+			...binding && (indexKey || node.key == null) ? { importedList: member ? {
+				source: binding.source,
+				imported: member
+			} : binding } : {}
+		});
+	}
+	for (const key of CHILD_NODE_KEYS) if (key in node) collectEachBlocks(node[key], source, acc, lists, imports);
 }
 /**
 * Whether a CallExpression *creates an effect*: `$effect(...)` or `$effect.pre(...)`.
@@ -132,6 +297,14 @@ function isEffectRootCall(node) {
 * `$state.raw(...)`, or `$state.frozen(...)` — but NOT readers like
 * `$state.snapshot(...)`, which would otherwise pollute the state-name set (correctness/effect-as-derived).
 */
+/** An absent argument or a literal no reader can write through: `0`, `'x'`, `null`, `-1`, `` `x` ``. */
+function isPrimitiveLiteral(node) {
+	if (node === void 0) return true;
+	if (node.type === "Literal") return !("regex" in node);
+	if (node.type === "TemplateLiteral") return node.expressions.length === 0;
+	if (node.type === "UnaryExpression") return node.argument?.type === "Literal";
+	return node.type === "Identifier" && node.name === "undefined";
+}
 function isStateDeclaration(node) {
 	const c = node?.callee;
 	if (c?.type === "Identifier") return c.name === "$state";
@@ -140,7 +313,18 @@ function isStateDeclaration(node) {
 }
 /** True when a function's body does nothing but assign to `$state` identifiers (correctness/effect-as-derived). */
 function bodyOnlyAssignsState(fn, stateNames) {
-	const isStateAssign = (expr) => expr?.type === "AssignmentExpression" && expr.operator === "=" && expr.left?.type === "Identifier" && stateNames.has(expr.left.name);
+	const readsItself = (expr) => {
+		let reads = false;
+		const names = /* @__PURE__ */ new Set();
+		walkEstree(expr.right, (n) => {
+			if (n?.type === "MemberExpression" && !n.computed) names.add(n.property);
+			if (n?.type === "Property" && !n.computed && !n.shorthand) names.add(n.key);
+			if (n?.type === "TSTypeQuery") names.add(n.exprName);
+			reads ||= n?.type === "Identifier" && n.name === expr.left.name && !names.has(n);
+		});
+		return reads;
+	};
+	const isStateAssign = (expr) => expr?.type === "AssignmentExpression" && expr.operator === "=" && expr.left?.type === "Identifier" && stateNames.has(expr.left.name) && !readsItself(expr);
 	const body = fn?.body;
 	if (!body) return false;
 	if (body.type !== "BlockStatement") return isStateAssign(body);
@@ -154,7 +338,37 @@ function isDerivedDeclaration(node) {
 	if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$derived") return c.property?.type === "Identifier" && c.property.name === "by";
 	return false;
 }
-function collectStateWrites(root, stateNames, acc, kinds) {
+const OBJECT_TYPES = /* @__PURE__ */ new Set([
+	"TSArrayType",
+	"TSTupleType",
+	"TSTypeLiteral"
+]);
+const OBJECT_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"Array",
+	"ReadonlyArray",
+	"Record",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Date"
+]);
+const OBJECT_VALUES = /* @__PURE__ */ new Set([
+	"ObjectExpression",
+	"ArrayExpression",
+	"NewExpression"
+]);
+/** A `$state` call whose initial value or type argument is an object, array or class instance. */
+function isObjectState(call) {
+	const arg = unwrapTs(call.arguments?.[0]);
+	if (isPrimitiveLiteral(arg)) return false;
+	if (OBJECT_VALUES.has(arg?.type)) return true;
+	if (arg?.type === "LogicalExpression" && arg.operator !== "&&" && !isPrimitiveLiteral(unwrapTs(arg.left)) && OBJECT_VALUES.has(unwrapTs(arg.right)?.type)) return true;
+	const type = (call.typeArguments ?? call.typeParameters)?.params?.[0];
+	if (type?.type === "TSTypeReference") return OBJECT_TYPE_NAMES.has(type.typeName?.name);
+	return OBJECT_TYPES.has(type?.type);
+}
+function collectStateWrites(root, stateNames, acc, kinds, localStates = false) {
 	const record = (name, kind) => {
 		acc.add(name);
 		if (kinds) {
@@ -163,14 +377,38 @@ function collectStateWrites(root, stateNames, acc, kinds) {
 			set.add(kind);
 		}
 	};
-	walkScoped(root, (n, scope) => {
+	const primitiveStates = /* @__PURE__ */ new Set();
+	const objectStates = /* @__PURE__ */ new Set();
+	const heldObjects = /* @__PURE__ */ new Set();
+	walkEstree(root, (n) => {
+		const init = n?.type === "VariableDeclarator" ? unwrapTs(n.init) : void 0;
+		if (n?.id?.type !== "Identifier" || !isStateDeclaration(init)) return;
+		(isPrimitiveLiteral(init.arguments?.[0]) ? primitiveStates : objectStates).add(n.id.name);
+		if (localStates && isObjectState(init)) heldObjects.add(n.id.name);
+	});
+	for (const name of objectStates) primitiveStates.delete(name);
+	const aliasOf = /* @__PURE__ */ new Map();
+	const reassigned = /* @__PURE__ */ new Set();
+	if (localStates) walkEstree(root, (n) => {
+		const target = n?.type === "AssignmentExpression" ? n.left : n?.type === "UpdateExpression" ? n.argument : void 0;
+		if (target?.type === "Identifier") reassigned.add(target.name);
+	});
+	if (localStates) for (let pass = 0; pass < 2; pass++) walkEstree(root, (n) => {
+		const [id, from] = n?.type === "VariableDeclarator" && unwrapTs(n.init)?.type === "MemberExpression" ? [n.id, n.init] : n?.type === "ForOfStatement" && n.left?.type === "VariableDeclaration" ? [n.left.declarations?.[0]?.id, n.right] : [void 0, void 0];
+		const r = rootObjectName(unwrapTs(from));
+		const owner = r && (stateNames.has(r) ? r : aliasOf.get(r));
+		if (id?.type === "Identifier" && owner && !stateNames.has(id.name) && !reassigned.has(id.name)) aliasOf.set(id.name, owner);
+	});
+	const visit = (stateNames) => (n, scope) => {
 		const shadowed = (name) => name === void 0 || scope.has(name);
+		const mutated = (r) => {
+			if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
+			else if (r && stateNames.has(aliasOf.get(r))) record(aliasOf.get(r), "mutate");
+		};
 		if (n?.type === "AssignmentExpression") {
 			if (n.left?.type === "Identifier" && stateNames.has(n.left.name) && !shadowed(n.left.name)) record(n.left.name, "reassign");
-			else if (n.left?.type === "MemberExpression") {
-				const r = rootObjectName(n.left);
-				if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
-			} else if (n.left?.type === "ObjectPattern" || n.left?.type === "ArrayPattern") {
+			else if (n.left?.type === "MemberExpression") mutated(rootObjectName(n.left));
+			else if (n.left?.type === "ObjectPattern" || n.left?.type === "ArrayPattern") {
 				const bound = /* @__PURE__ */ new Set();
 				addBoundNames(n.left, bound);
 				for (const name of bound) if (stateNames.has(name) && !shadowed(name)) record(name, "reassign");
@@ -178,24 +416,41 @@ function collectStateWrites(root, stateNames, acc, kinds) {
 		} else if (n?.type === "UpdateExpression") {
 			if (n.argument?.type === "Identifier") {
 				if (stateNames.has(n.argument.name) && !shadowed(n.argument.name)) record(n.argument.name, "reassign");
-			} else {
-				const r = rootObjectName(n.argument);
-				if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
-			}
-		} else if (n?.type === "UnaryExpression" && n.operator === "delete") {
-			const r = rootObjectName(n.argument);
-			if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
-		} else if (n?.type === "CallExpression") {
-			if (n.callee?.type === "MemberExpression") {
-				const r = rootObjectName(n.callee);
-				if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
-			}
+			} else mutated(rootObjectName(n.argument));
+		} else if (n?.type === "UnaryExpression" && n.operator === "delete") mutated(rootObjectName(n.argument));
+		else if (n?.type === "CallExpression") {
+			if (n.callee?.type === "MemberExpression") mutated(rootObjectName(n.callee));
 			for (const a of n.arguments ?? []) {
 				const arg = a?.type === "SpreadElement" ? a.argument : a;
 				const r = rootObjectName(arg);
 				if (r && stateNames.has(r) && !shadowed(r)) record(r, "escape");
 			}
+		} else if (n?.type === "ReturnStatement") {
+			const out = unwrapTs(n.argument);
+			const r = out?.type === "Identifier" ? out.name : void 0;
+			if (r && stateNames.has(r) && !shadowed(r) && !primitiveStates.has(r)) record(r, "escape");
+		} else if (heldObjects.size > 0 && (n?.type === "ObjectExpression" || n?.type === "ArrayExpression")) {
+			const values = n.type === "ObjectExpression" ? (n.properties ?? []).map((p) => p?.value) : n.elements;
+			for (const v of values ?? []) {
+				const placed = unwrapTs(v);
+				const r = placed?.type === "Identifier" ? placed.name : void 0;
+				if (r && heldObjects.has(r) && stateNames.has(r) && !shadowed(r)) record(r, "escape");
+			}
+		} else if ((n?.type === "Property" || n?.type === "MethodDefinition") && n.kind === "get") walkEstree(n.value?.body, (m) => {
+			const r = m?.type === "ReturnStatement" ? rootObjectName(m.argument) : void 0;
+			if (r && stateNames.has(r) && !shadowed(r) && !primitiveStates.has(r)) record(r, "escape");
+		});
+	};
+	walkScoped(root, visit(stateNames));
+	if (!localStates) return;
+	walkEstree(root, (n) => {
+		if (n.type !== "BlockStatement") return;
+		const own = /* @__PURE__ */ new Set();
+		for (const stmt of n.body ?? []) {
+			if (stmt?.type !== "VariableDeclaration") continue;
+			for (const d of stmt.declarations ?? []) if (d?.id?.type === "Identifier" && stateNames.has(d.id.name) && isStateDeclaration(unwrapTs(d.init))) own.add(d.id.name);
 		}
+		if (own.size > 0) walkScoped(n.body, visit(own));
 	});
 }
 /** Function-shaped nodes whose bodies defer evaluation — prop reads inside them stay reactive (compiled to call-time reads). */
@@ -421,16 +676,17 @@ function collectFragmentAliasRefs(node, names, acc, shadowed = /* @__PURE__ */ n
 	}
 }
 /**
-* Each-context taint (performance/state-raw condition 5): for `{#each candidate as item}`
+* Each-context taint (performance/state-raw condition 5, correctness/unmutated-state): for `{#each candidate as item}`
 * or `{#each candidate.path as item}`, any mutate/escape of the context binding (or index)
 * inside the block — member writes, method calls, call arguments, `bind:`, component props —
 * disqualifies the candidate over the candidate or a member path of it
 * (`{#each obj.items as item}`): item-level edits stop being reactive under $state.raw.
 * Pure reassignments of the context name are ignored (they don't touch the list's contents).
+* `includeIndex: false` ignores the index binding, a number that cannot carry a write back to the list.
 */
-function collectEachContextTaint(node, names, acc, shadowed = /* @__PURE__ */ new Set()) {
+function collectEachContextTaint(node, names, acc, shadowed = /* @__PURE__ */ new Set(), includeIndex = true) {
 	if (Array.isArray(node)) {
-		for (const child of node) collectEachContextTaint(child, names, acc, shadowed);
+		for (const child of node) collectEachContextTaint(child, names, acc, shadowed, includeIndex);
 		return;
 	}
 	if (!node || typeof node !== "object" || typeof node.type !== "string") return;
@@ -442,7 +698,7 @@ function collectEachContextTaint(node, names, acc, shadowed = /* @__PURE__ */ ne
 		if (target !== void 0 && names.has(target) && !shadowed.has(target)) {
 			const ctxNames = /* @__PURE__ */ new Set();
 			addBoundNames(node.context, ctxNames);
-			if (typeof node.index === "string") ctxNames.add(node.index);
+			if (includeIndex && typeof node.index === "string") ctxNames.add(node.index);
 			if (ctxNames.size > 0) {
 				const union = /* @__PURE__ */ new Set();
 				const kinds = /* @__PURE__ */ new Map();
@@ -457,7 +713,7 @@ function collectEachContextTaint(node, names, acc, shadowed = /* @__PURE__ */ ne
 	}
 	for (const key of Object.keys(node)) {
 		if (WALK_IGNORED_KEYS.has(key)) continue;
-		collectEachContextTaint(node[key], names, acc, scope);
+		collectEachContextTaint(node[key], names, acc, scope, includeIndex);
 	}
 }
 /**
@@ -656,6 +912,30 @@ function collectNewExprLocalNames(program, acc) {
 	});
 }
 /**
+* Top-level locals declared as a plain alias of an imported binding or a `new …()` local
+* (`const p = presenter`, `const p = presenter as Presenter`), to a fixed point so alias chains resolve in any order
+* (correctness/effect-as-onmount). Top level only: names match by text, not scope, so a
+* function-local `const id = presenter` would otherwise mark every `id` in the component reactive.
+* Runs before rune names are added: an alias of a `$state` primitive is a non-reactive snapshot.
+*/
+function collectAliasLocalNames(program, acc) {
+	const declarators = (program?.body ?? []).flatMap((stmt) => {
+		const decl = unwrapExport(stmt);
+		return decl?.type === "VariableDeclaration" ? decl.declarations : [];
+	});
+	for (let grew = true; grew;) {
+		grew = false;
+		for (const d of declarators) {
+			if (d.id?.type !== "Identifier" || !d.init || acc.has(d.id.name)) continue;
+			const init = unwrapTs(d.init);
+			if (init.type === "Identifier" && acc.has(init.name)) {
+				acc.add(d.id.name);
+				grew = true;
+			}
+		}
+	}
+}
+/**
 * Whether an $effect callback body reads a reactive value (correctness/effect-as-onmount, conservative):
 * a reactive name (rune declarator, imported binding, or a local declared with a `new …()`
 * initializer — see `collectImportedLocalNames`/`collectNewExprLocalNames`), a `$`-prefixed
@@ -851,10 +1131,12 @@ function collectAriaElements(node, source, acc) {
 			const hasList = tag === "input" && findAttr(node.attributes, "list") !== void 0;
 			const selectKind = tag === "select" ? selectNativeRole(node.attributes) : void 0;
 			const hasSpread = node.attributes.some((a) => a?.type === "SpreadAttribute");
+			const hasAction = node.attributes.some((a) => a?.type === "UseDirective");
 			acc.push({
 				tag,
 				line: lineOf(source, node.start),
 				...roleAttr ? { role: classifyAttrValue(roleAttr.value) } : {},
+				...hasAction ? { hasAction: true } : {},
 				...inputType !== void 0 ? { inputType: inputType.toLowerCase() } : {},
 				...hasList ? { hasList: true } : {},
 				...selectKind ? { selectKind } : {},
@@ -989,10 +1271,13 @@ function hasNamingAttr(attributes) {
 		"title"
 	].some((name) => hasNamingValue(attributes, name));
 }
-/** A tag name with a hyphen is a custom element: it may be form-associated, and its shadow root may
-*  supply content, neither of which is visible here. Treated as unknowable by both a11y scanners. */
+/** A custom element may be form-associated and its shadow root may supply content; a namespaced tag
+*  (`<enhanced:img>`) is rewritten by a preprocessor into markup not visible here. Treated as
+*  unknowable by both a11y scanners. */
 function isCustomElement(node) {
-	return node.type === "RegularElement" && typeof node.name === "string" && node.name.includes("-");
+	if (node.type !== "RegularElement" || typeof node.name !== "string") return false;
+	const tag = node.name.toLowerCase();
+	return tag.includes("-") || !KNOWN_TAGS.has(tag);
 }
 function scanAccessibleNameSubtree(node, skip) {
 	if (Array.isArray(node)) {
@@ -1542,6 +1827,7 @@ function isPropsCall(node) {
 }
 /** Whether a CallExpression is a `$bindable(...)` call (a destructured prop's default value). */
 function isBindableCall(node) {
+	node = unwrapTs(node);
 	return node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "$bindable";
 }
 /**
@@ -1591,6 +1877,7 @@ function collectLegacyPropNames(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 ?? []) if (d?.id?.type === "Identifier") names.add(d.id.name);
 	}
 	return names;
@@ -1611,6 +1898,92 @@ const MUTATING_METHODS = /* @__PURE__ */ new Set([
 	"delete",
 	"clear"
 ]);
+/** Built-in types whose own methods include the mutating method names above. */
+const COLLECTION_TYPES = /* @__PURE__ */ new Set([
+	"Array",
+	"ReadonlyArray",
+	"Set",
+	"ReadonlySet",
+	"Map",
+	"ReadonlyMap",
+	"WeakMap",
+	"WeakSet",
+	"SvelteSet",
+	"SvelteMap",
+	"URLSearchParams",
+	"SvelteURLSearchParams",
+	"FormData",
+	"Headers",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float16Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+]);
+const NON_COLLECTION_NODES = /* @__PURE__ */ new Set([
+	"TSStringKeyword",
+	"TSNumberKeyword",
+	"TSBooleanKeyword",
+	"TSBigIntKeyword",
+	"TSNullKeyword",
+	"TSUndefinedKeyword",
+	"TSFunctionType",
+	"TSTypeLiteral",
+	"TSLiteralType"
+]);
+/**
+* The props whose declared type, from the `$props()` annotation, is known not to be a collection: a
+* method called on one is its own API (`queryClient.clear()`), not an array, Set or Map mutation.
+* A named type counts unless it is a built-in collection or a same-file alias of one.
+*/
+function nonCollectionProps(program) {
+	const decls = /* @__PURE__ */ new Map();
+	walkEstree(program, (n) => {
+		if ((n.type === "TSInterfaceDeclaration" || n.type === "TSTypeAliasDeclaration") && n.id?.name) decls.set(n.id.name, n);
+	});
+	const unwrap = (t) => t?.type === "TSTypeAnnotation" ? t.typeAnnotation : t;
+	const nonCollection = (t, depth) => {
+		t = unwrap(t);
+		if (!t || depth > 4) return false;
+		if (NON_COLLECTION_NODES.has(t.type)) return true;
+		if (t.type === "TSUnionType") return t.types.every((u) => nonCollection(u, depth + 1));
+		if (t.type !== "TSTypeReference" || t.typeName?.type !== "Identifier") return false;
+		const name = t.typeName.name;
+		if (COLLECTION_TYPES.has(name)) return false;
+		const decl = decls.get(name);
+		if (decl?.type === "TSTypeAliasDeclaration") return nonCollection(decl.typeAnnotation, depth + 1);
+		if (decl?.type === "TSInterfaceDeclaration") return !(decl.extends ?? []).some((h) => COLLECTION_TYPES.has(h.expression?.name));
+		return !(t.typeArguments ?? t.typeParameters)?.params?.length;
+	};
+	const membersOf = (t, depth) => {
+		t = unwrap(t);
+		if (t?.type === "TSTypeLiteral") return t.members;
+		if (t?.type !== "TSTypeReference" || depth > 4) return void 0;
+		const decl = decls.get(t.typeName?.name);
+		if (decl?.type === "TSInterfaceDeclaration") return decl.body?.body;
+		return decl?.type === "TSTypeAliasDeclaration" ? membersOf(decl.typeAnnotation, depth + 1) : void 0;
+	};
+	const names = /* @__PURE__ */ new Set();
+	walkEstree(program, (n) => {
+		if (n.type !== "VariableDeclarator" || !n.init || !isPropsCall(unwrapTs(n.init))) return;
+		if (n.id?.type !== "ObjectPattern") return;
+		const types = /* @__PURE__ */ new Map();
+		for (const m of membersOf(n.id.typeAnnotation, 0) ?? []) if (m.type === "TSPropertySignature" && m.key?.type === "Identifier") types.set(m.key.name, m.typeAnnotation);
+		for (const p of n.id.properties ?? []) {
+			if (p?.type !== "Property" || p.key?.type !== "Identifier" || !types.has(p.key.name)) continue;
+			const local = p.value?.type === "AssignmentPattern" ? p.value.left : p.value;
+			if (local?.type === "Identifier" && nonCollection(types.get(p.key.name), 0)) names.add(local.name);
+		}
+	});
+	return names;
+}
 /**
 * Flag mutations of a non-`$bindable` prop (correctness/prop-mutation): a member-expression write
 * (`prop.x = …`, `prop.x += …`, `prop.x++`), `delete prop.x`, or a call to a mutating
@@ -1619,9 +1992,43 @@ const MUTATING_METHODS = /* @__PURE__ */ new Set([
 * reassignment for ephemeral state; only mutation is prohibited. Run over the instance
 * program AND the template fragment (inline handlers can mutate props in the template).
 * Scope-aware (issue #140): a local that shadows the prop's name is not flagged.
+* A `legacy` (export let) prop is flagged only for `delete` and mutating method calls — the legacy
+* compiler turns a member write or update into an invalidating assignment (`prop(prop().x = …, true)`).
 */
-function collectPropMutations(root, propNames, source, acc) {
+function collectPropMutations(root, propNames, source, acc, legacy, ownApi = /* @__PURE__ */ new Set()) {
 	if (propNames.size === 0) return;
+	const exemptCalls = /* @__PURE__ */ new Set();
+	const returnedToProp = /* @__PURE__ */ new Set();
+	if (legacy.size > 0) walkEstree(root, (fn) => {
+		const body = isDeferredBody(fn) ? fn.body : fn.type === "LabeledStatement" && fn.label?.name === "$" ? fn.body : void 0;
+		if (!body) return;
+		const assigned = /* @__PURE__ */ new Set();
+		walkScoped(body, (m, scope) => {
+			if (m.type === "AssignmentExpression" && m.left?.type === "Identifier" && !scope.has(m.left.name)) assigned.add(m.left.name);
+		});
+		walkEstree(body, (m) => {
+			const r = m.type === "CallExpression" ? rootObjectName(m.callee?.object) : m.type === "UnaryExpression" && m.operator === "delete" ? rootObjectName(m.argument) : void 0;
+			if (r && legacy.has(r) && assigned.has(r)) exemptCalls.add(m);
+		});
+	});
+	walkEstree(root, (m) => {
+		const call = m.type === "AssignmentExpression" && m.left?.type === "Identifier" ? m.right : void 0;
+		if (call?.type === "CallExpression" && rootObjectName(call.callee?.object) === m.left.name && call.arguments?.length === 1 && call.arguments[0]?.type === "ObjectExpression") exemptCalls.add(call);
+		const awaited = m.type === "AwaitExpression" ? unwrapTs(m.argument) : void 0;
+		if (awaited?.type === "CallExpression") exemptCalls.add(awaited);
+		const chained = m.type === "CallExpression" && m.callee?.type === "MemberExpression" && !m.callee.computed && [
+			"then",
+			"catch",
+			"finally"
+		].includes(m.callee.property?.name) ? unwrapTs(m.callee.object) : void 0;
+		if (chained?.type === "CallExpression") exemptCalls.add(chained);
+		if (m.type === "AssignmentExpression" && m.left?.type === "Identifier") {
+			let back = unwrapTs(m.right);
+			if (back?.type === "LogicalExpression") back = unwrapTs(back.left);
+			if (back?.type === "ChainExpression") back = back.expression;
+			if (back?.type === "CallExpression" && back.callee.type === "MemberExpression" && rootObjectName(back.callee.object) === m.left.name) returnedToProp.add(back);
+		}
+	});
 	walkScoped(root, (n, scope) => {
 		const flag = (r) => {
 			if (r && propNames.has(r) && !scope.has(r)) acc.push({
@@ -1629,11 +2036,18 @@ function collectPropMutations(root, propNames, source, acc) {
 				line: lineOf(source, n.start)
 			});
 		};
-		if (n.type === "AssignmentExpression" && n.left?.type === "MemberExpression") flag(rootObjectName(n.left));
-		else if (n.type === "UpdateExpression" && n.argument?.type === "MemberExpression") flag(rootObjectName(n.argument));
-		else if (n.type === "UnaryExpression" && n.operator === "delete") flag(rootObjectName(n.argument));
+		if (exemptCalls.has(n)) return;
+		if (n.type === "AssignmentExpression" && n.left?.type === "MemberExpression") {
+			const r = rootObjectName(n.left);
+			if (r && !legacy.has(r)) flag(r);
+		} else if (n.type === "UpdateExpression" && n.argument?.type === "MemberExpression") {
+			const r = rootObjectName(n.argument);
+			if (r && !legacy.has(r)) flag(r);
+		} else if (n.type === "UnaryExpression" && n.operator === "delete") flag(rootObjectName(n.argument));
 		else if (n.type === "CallExpression" && n.callee?.type === "MemberExpression") {
 			const method = n.callee.property?.type === "Identifier" ? n.callee.property.name : void 0;
+			const receiver = unwrapTs(n.callee.object);
+			if (receiver?.type === "Identifier" && ownApi.has(receiver.name) && !returnedToProp.has(n)) return;
 			if (method && MUTATING_METHODS.has(method)) flag(rootObjectName(n.callee.object));
 		}
 	});
@@ -1666,27 +2080,66 @@ function isTypeOnlyImport(n) {
 	const specs = n.specifiers;
 	return Array.isArray(specs) && specs.length > 0 && specs.every((s) => s?.importKind === "type");
 }
+/** Whether an import declaration binds only named exports — no default, `default as`, or namespace (see `ComponentFacts.importSpans`). */
+function isNamedOnlyImport(n) {
+	const specs = n.specifiers;
+	return Array.isArray(specs) && specs.length > 0 && specs.every((s) => s?.type === "ImportSpecifier" && (s.imported?.name ?? s.imported?.value) !== "default");
+}
 /** Module specifiers of every `import`, each with its source line (see `ComponentFacts.importSpans`). */
 function collectImportSources(program, source, acc) {
 	walkEstree(program, (n) => {
 		if (n.type === "ImportDeclaration" && typeof n.source?.value === "string") acc.push({
 			source: n.source.value,
 			line: lineOf(source, n.start),
-			...isTypeOnlyImport(n) ? { type: true } : {}
+			...isTypeOnlyImport(n) ? { type: true } : isNamedOnlyImport(n) ? { named: true } : {}
 		});
 	});
 }
 /** A specifier is "bare" (a node_modules package) when it is not relative/absolute/alias-local. */
 function isBareSpecifier(s) {
-	return !/^[./$#]/.test(s);
+	return !/^([./$#]|@\/|~\/)/.test(s);
 }
-/** Value `import * as X from '<bare pkg>'` namespace imports (type-only excluded) — performance/namespace-import. */
-function collectNamespaceImports(program, source, acc) {
+/**
+* Whether `name` is used anywhere in `roots` other than as the object of a static member access
+* (`X.foo`, `X['foo']`) — passing `X` on, spreading it or indexing it by a variable is what makes
+* a bundler keep the whole module. `<X.Foo />` in markup is a component name, not an identifier,
+* so it counts as static. A same-named local (`scopeIntroducedNames`) shadows the namespace.
+*/
+function namespaceUsedDynamically(name, roots) {
+	const staticOrDeclaring = /* @__PURE__ */ new Set();
+	for (const root of roots) walkEstree(root, (n) => {
+		if (n.type === "MemberExpression") {
+			const literalKey = n.computed && n.property?.type === "Literal" && typeof n.property.value === "string";
+			if (n.object?.type === "Identifier" && n.object.name === name && (!n.computed || literalKey)) staticOrDeclaring.add(n.object);
+			if (!n.computed) staticOrDeclaring.add(n.property);
+		} else if ((n.type === "Property" && !n.shorthand || n.type === "TSPropertySignature" || n.type === "TSMethodSignature") && !n.computed) staticOrDeclaring.add(n.key);
+		else if (n.type === "ImportNamespaceSpecifier") staticOrDeclaring.add(n.local);
+		else if (n.type === "ImportSpecifier" && n.imported !== n.local) staticOrDeclaring.add(n.imported);
+		else if (n.type === "ExportSpecifier" && n.exported !== n.local) staticOrDeclaring.add(n.exported);
+		else if (n.type === "TSQualifiedName" || n.type === "TSTypeQuery") {
+			const id = n.type === "TSQualifiedName" ? n.left : n.exprName;
+			if (id?.type === "Identifier") staticOrDeclaring.add(id);
+			if (n.type === "TSQualifiedName") staticOrDeclaring.add(n.right);
+		}
+	});
+	let dynamic = false;
+	for (const root of roots) walkScoped(root, (n, shadowed) => {
+		if (n.type === "Identifier" && n.name === name && !staticOrDeclaring.has(n) && !shadowed.has(name)) dynamic = true;
+	});
+	return dynamic;
+}
+/**
+* Value `import * as X from '<bare pkg>'` namespace imports (type-only excluded) that `roots` (every
+* program and template of the file) use dynamically — performance/namespace-import. Static member
+* accesses tree-shake like named imports, so a namespace used only that way is not reported.
+*/
+function collectNamespaceImports(program, source, acc, roots) {
 	walkEstree(program, (n) => {
 		if (n.type !== "ImportDeclaration" || n.importKind === "type") return;
 		const spec = n.source?.value;
 		if (typeof spec !== "string" || !isBareSpecifier(spec)) return;
-		if (Array.isArray(n.specifiers) && n.specifiers.some((s) => s?.type === "ImportNamespaceSpecifier")) acc.push({
+		const ns = (n.specifiers ?? []).find((s) => s?.type === "ImportNamespaceSpecifier");
+		if (ns?.local?.type === "Identifier" && namespaceUsedDynamically(ns.local.name, roots)) acc.push({
 			source: spec,
 			line: lineOf(source, n.start)
 		});
@@ -1931,7 +2384,7 @@ function parseModuleFacts(source, filename) {
 			line: shift(s.line)
 		});
 		const rawNamespaceImports = [];
-		collectNamespaceImports(program, wrapped, rawNamespaceImports);
+		collectNamespaceImports(program, wrapped, rawNamespaceImports, [program]);
 		for (const n of rawNamespaceImports) namespaceImports.push({
 			...n,
 			line: shift(n.line)
@@ -1971,7 +2424,10 @@ function parseComponentFacts(source, filename) {
 	if (MODULE_FILE_RE.test(filename)) return parseModuleFacts(source, filename);
 	const ast = parseSvelte(source, filename);
 	const eachBlocks = [];
-	collectEachBlocks(ast.fragment ?? ast, source, eachBlocks);
+	const scriptPrograms = [ast.module?.content, ast.instance?.content].filter(Boolean);
+	const listImports = /* @__PURE__ */ new Map();
+	const lists = collectConstantLists(scriptPrograms, ast.fragment ?? ast, { imports: listImports });
+	collectEachBlocks(ast.fragment ?? ast, source, eachBlocks, lists, listImports);
 	const htmlTags = [];
 	const javascriptUrls = [];
 	collectSecurityFacts(ast.fragment ?? ast, source, htmlTags, javascriptUrls);
@@ -2016,17 +2472,26 @@ function parseComponentFacts(source, filename) {
 	const moduleProgram = ast.module?.content;
 	const importSpans = [];
 	const namespaceImports = [];
+	const usageRoots = [
+		moduleProgram,
+		ast.instance?.content,
+		ast.fragment
+	].filter(Boolean);
 	if (moduleProgram) {
 		collectImportSources(moduleProgram, source, importSpans);
-		collectNamespaceImports(moduleProgram, source, namespaceImports);
+		collectNamespaceImports(moduleProgram, source, namespaceImports, usageRoots);
 	}
 	const orphanEffects = moduleProgram ? collectOrphanEffects(moduleProgram, source) : [];
 	const orphanLifecycleCalls = moduleProgram ? collectOrphanLifecycleCalls(moduleProgram, source) : [];
 	const browserGlobalRefs = [];
-	if (moduleProgram) for (const r of collectBrowserGlobalRefs(moduleProgram, source)) browserGlobalRefs.push({
-		...r,
-		context: "module"
-	});
+	if (moduleProgram) {
+		const hoisted = /* @__PURE__ */ new Set();
+		collectImportedLocalNames(ast.instance?.content, hoisted);
+		for (const r of collectBrowserGlobalRefs(moduleProgram, source, { bound: hoisted })) browserGlobalRefs.push({
+			...r,
+			context: "module"
+		});
+	}
 	const effects = [];
 	const constableStates = [];
 	const mutatedProps = [];
@@ -2037,13 +2502,15 @@ function parseComponentFacts(source, filename) {
 	const program = ast.instance?.content;
 	if (program) {
 		collectImportSources(program, source, importSpans);
-		collectNamespaceImports(program, source, namespaceImports);
+		collectNamespaceImports(program, source, namespaceImports, usageRoots);
 		propCount = countProps(program);
 		const legacyPropNames = collectLegacyPropNames(program);
 		const nonBindableProps = /* @__PURE__ */ new Set([...collectPropNames(program, false), ...legacyPropNames]);
 		const rawMutations = [];
-		collectPropMutations(program, nonBindableProps, source, rawMutations);
-		if (ast.fragment) collectPropMutations(ast.fragment, nonBindableProps, source, rawMutations);
+		const ownApi = nonCollectionProps(program);
+		collectPropMutations(program, nonBindableProps, source, rawMutations, legacyPropNames, ownApi);
+		if (ast.fragment) collectPropMutations(ast.fragment, nonBindableProps, source, rawMutations, legacyPropNames, ownApi);
+		const isLegacy = legacyPropNames.size > 0;
 		for (const m of rawMutations) mutatedProps.push(legacyPropNames.has(m.name) ? {
 			...m,
 			legacy: true
@@ -2061,7 +2528,6 @@ function parseComponentFacts(source, filename) {
 				}
 				const referenced = /* @__PURE__ */ new Set();
 				if (ast.fragment) collectFragmentRefs(ast.fragment, candidateNames, referenced);
-				const isLegacy = legacyPropNames.size > 0;
 				for (const c of candidates) if (!disqualified.has(c.name) && referenced.has(c.name)) stalePropDerivations.push(isLegacy ? {
 					...c,
 					legacy: true
@@ -2075,7 +2541,9 @@ function parseComponentFacts(source, filename) {
 		if (moduleProgram) {
 			collectImportedLocalNames(moduleProgram, reactiveNames);
 			collectNewExprLocalNames(moduleProgram, reactiveNames);
+			collectAliasLocalNames(moduleProgram, reactiveNames);
 		}
+		collectAliasLocalNames(program, reactiveNames);
 		const stateDecls = [];
 		walkEstree(program, (n) => {
 			if (n.type !== "VariableDeclarator" || !n.init) return;
@@ -2100,11 +2568,12 @@ function parseComponentFacts(source, filename) {
 			});
 		});
 		const writtenOrEscaped = /* @__PURE__ */ new Set();
-		collectStateWrites(program, stateNames, writtenOrEscaped);
+		collectStateWrites(program, stateNames, writtenOrEscaped, void 0, true);
 		if (ast.fragment) {
-			collectStateWrites(ast.fragment, stateNames, writtenOrEscaped);
+			collectStateWrites(ast.fragment, stateNames, writtenOrEscaped, void 0, true);
 			collectTemplateEscapes(ast.fragment, stateNames, writtenOrEscaped);
 			collectDirectiveEscapes(ast.fragment, stateNames, writtenOrEscaped);
+			collectEachContextTaint(ast.fragment, stateNames, writtenOrEscaped, /* @__PURE__ */ new Set(), false);
 		}
 		for (const d of stateDecls) if (!writtenOrEscaped.has(d.name)) constableStates.push(d);
 		const rawableCandidates = [];
@@ -2458,7 +2927,7 @@ async function collectKitModuleFacts(rt, cwd, aliases) {
 		"src/hooks.server.{ts,js}"
 	].map((p) => rt.glob(p, cwd)));
 	const files = [...new Set(lists.flat())];
-	return arbitrateServerStoreWrites(rt, cwd, await Promise.all(files.sort().map(async (rel) => {
+	return decideLoadFactories(rt, cwd, await decideFlagGuards(rt, cwd, await dropClientWrites(rt, cwd, await arbitrateServerStoreWrites(rt, cwd, await Promise.all(files.sort().map(async (rel) => {
 		const kind = kindOf(rel);
 		let source;
 		try {
@@ -2482,7 +2951,7 @@ async function collectKitModuleFacts(rt, cwd, aliases) {
 				parseFailed: true
 			};
 		}
-	})));
+	}))), aliases)));
 }
 /**
 * The files a resolved specifier may name, in resolution order. An extensionless path takes an
@@ -2500,20 +2969,58 @@ function moduleCandidates(repoPath) {
 		`${repoPath}/index.js`
 	];
 }
-/**
-* Read the module a pending write targets and return the names it exports as an in-memory
-* container. Returns an empty set when the file cannot be found or read: unresolvable means
-* unarbitrated, which leaves the write exempt.
-*/
-async function inMemoryExportsOf(rt, cwd, repoPath) {
+/** Read a module and parse it with `parse`; empty when it cannot be found or read. */
+async function exportsOf(rt, cwd, repoPath, parse) {
 	for (const rel of moduleCandidates(repoPath)) try {
 		if (!await rt.exists(rt.join(cwd, rel))) continue;
-		return parseInMemoryExports(await rt.readFile(rt.join(cwd, rel)), rel);
+		return parse(await rt.readFile(rt.join(cwd, rel)), rel);
 	} catch {
 		return /* @__PURE__ */ new Set();
 	}
 	return /* @__PURE__ */ new Set();
 }
+/** Drop the handler `.set()`/`.update()` writes whose target module exports a persistence client under that name. */
+async function dropClientWrites(rt, cwd, facts, aliases) {
+	const targets = [...new Set(facts.flatMap((f) => (f.storeWriteTargets ?? []).map((w) => w.resolved)))];
+	if (targets.length === 0) return facts;
+	const byPath = new Map(await Promise.all(targets.map(async (t) => [t, await exportsOf(rt, cwd, t, (src, file) => parseClientExports(src, file, aliases))])));
+	return facts.map((f) => {
+		const clients = (f.storeWriteTargets ?? []).filter((w) => byPath.get(w.resolved)?.has(w.imported));
+		if (clients.length === 0) return f;
+		const drop = (w) => w.via === "set-call" && clients.some((c) => c.name === w.name && c.line === w.line);
+		return {
+			...f,
+			importedStateWrites: f.importedStateWrites.filter((w) => !drop(w))
+		};
+	});
+}
+/** A `load` an imported factory builds never renders when the function the factory returns always exits. */
+async function decideLoadFactories(rt, cwd, facts) {
+	const targets = [...new Set(facts.flatMap((f) => f.pendingLoadFactory ? [f.pendingLoadFactory.resolved] : []))];
+	if (targets.length === 0) return facts;
+	const byPath = new Map(await Promise.all(targets.map(async (t) => [t, await exportsOf(rt, cwd, t, parseExitFactoryExports)])));
+	return facts.map((f) => {
+		const g = f.pendingLoadFactory;
+		return g && byPath.get(g.resolved)?.has(g.name) ? {
+			...f,
+			loadNeverRenders: true
+		} : f;
+	});
+}
+/** A load whose leading guard exits on an imported flag that is the literal `false` never renders. */
+async function decideFlagGuards(rt, cwd, facts) {
+	const targets = [...new Set(facts.flatMap((f) => f.pendingFlagGuard ? [f.pendingFlagGuard.resolved] : []))];
+	if (targets.length === 0) return facts;
+	const byPath = new Map(await Promise.all(targets.map(async (t) => [t, await exportsOf(rt, cwd, t, parseFalseExports)])));
+	return facts.map((f) => {
+		const g = f.pendingFlagGuard;
+		const key = g && (g.member ? `${g.name}.${g.member}` : g.name);
+		return g && byPath.get(g.resolved)?.has(key) ? {
+			...f,
+			loadNeverRenders: true
+		} : f;
+	});
+}
 /**
 * Decide the `.set()`/`.update()` calls the parse could not: a call on a binding exported from
 * under the `$lib` server root is shared module state when that binding is an in-memory
@@ -2523,7 +3030,7 @@ async function inMemoryExportsOf(rt, cwd, repoPath) {
 async function arbitrateServerStoreWrites(rt, cwd, facts) {
 	const targets = [...new Set(facts.flatMap((f) => f.pendingServerStoreWrites.map((w) => w.resolved)))];
 	if (targets.length === 0) return facts;
-	const byPath = new Map(await Promise.all(targets.map(async (t) => [t, await inMemoryExportsOf(rt, cwd, t)])));
+	const byPath = new Map(await Promise.all(targets.map(async (t) => [t, await exportsOf(rt, cwd, t, parseInMemoryExports)])));
 	return facts.map((f) => {
 		const promoted = f.pendingServerStoreWrites.filter((w) => byPath.get(w.resolved)?.has(w.imported)).map((w) => ({
 			name: w.name,
@@ -2653,20 +3160,51 @@ function findMinifyDisabled(source) {
 }
 //#endregion
 //#region src/svelte-config-parse.ts
+function isServedBase(value) {
+	return typeof value === "string" && value.startsWith("/") && !value.endsWith("/");
+}
+/** The top-level bindings declared `const`: a `let` may be reassigned on the way to the export. */
+function constBindings(program, bindings) {
+	const names = /* @__PURE__ */ new Set();
+	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) if (d.id.type === "Identifier") names.add(d.id.name);
+	}
+	return new Map([...bindings].filter(([name]) => names.has(name)));
+}
+/** Whether no branch of a `?:` / `||` / `&&` / `??` tree is a literal base an app can be served under. */
+function neverABase(expr, consts) {
+	const e = resolveBinding(expr, consts);
+	if (e.type === "Literal") return !isServedBase(e.value);
+	if (e.type === "ConditionalExpression") return neverABase(e.consequent, consts) && neverABase(e.alternate, consts);
+	if (e.type === "LogicalExpression") return neverABase(e.left, consts) && neverABase(e.right, consts);
+	return false;
+}
+/** `expr` with top-level `const` names followed to their initializers (`paths: { base }` naming `const base = ''`). */
+function resolveBinding(expr, consts) {
+	let e = unwrapTs(expr);
+	for (let i = 0; i < 4 && e.type === "Identifier"; i++) {
+		const next = consts.get(e.name);
+		if (!next) break;
+		e = unwrapTs(next);
+	}
+	return e;
+}
 /**
 * `paths.base` off a resolved Kit-config object: `{ value }` for a non-empty string literal,
 * `{}` for any other expression (base exists, value unknowable — the `dev ? '' : '/repo'`
-* deploy form), and undefined when absent or an explicit empty string.
+* deploy form), and undefined when absent or when no value it can take is a base SvelteKit serves under.
 */
-function basePathOf(kitConfig, bindings) {
+function basePathOf(kitConfig, bindings, consts) {
 	const paths = propOf(kitConfig, "paths");
 	const pathsObj = paths ? unwrapToObjectExpression(paths.value, bindings) : void 0;
 	if (!pathsObj) return void 0;
 	const base = propOf(pathsObj, "base");
 	if (!base) return void 0;
-	const value = unwrapTs(base.value);
-	if (value.type === "Literal") return typeof value.value === "string" && value.value !== "" ? { value: value.value } : void 0;
-	return {};
+	const value = resolveBinding(base.value, consts);
+	if (value.type === "Literal") return isServedBase(value.value) ? { value: value.value } : void 0;
+	return neverABase(value, consts) ? void 0 : {};
 }
 /** A property's key when it is a plain (non-computed) string or identifier key. */
 function keyNameOf(p) {
@@ -2674,10 +3212,46 @@ function keyNameOf(p) {
 	if (p.key.type === "Identifier") return p.key.name;
 	if (p.key.type === "Literal" && typeof p.key.value === "string") return p.key.value;
 }
-/** A property's value when it is a string literal, else undefined. */
+function stringLiteralOf(expr) {
+	return expr?.type === "Literal" && typeof expr.value === "string" ? expr.value : void 0;
+}
+/** `__dirname`, `import.meta.dirname` or `process.cwd()`: the config's directory, which is the project root. */
+function isRootDir(expr) {
+	if (expr.type === "Identifier") return expr.name === "__dirname";
+	if (expr.type === "MemberExpression" && expr.property.type === "Identifier") return expr.object.type === "MetaProperty" && expr.property.name === "dirname";
+	return expr.type === "CallExpression" && expr.callee.type === "MemberExpression" && expr.callee.object.type === "Identifier" && expr.callee.object.name === "process" && expr.callee.property.type === "Identifier" && expr.callee.property.name === "cwd";
+}
+/**
+* A config path value, relative to the project root: a string literal, `resolve(…)`/`join(…)`
+* (bare or `path.`-qualified) of string literals led by an optional root directory, or
+* `fileURLToPath(new URL('<literal>', import.meta.url))`. Anything else is unreadable.
+*/
+function pathValueOf(value) {
+	const v = unwrapTs(value);
+	if (v.type !== "CallExpression") return stringLiteralOf(v);
+	const callee = v.callee.type === "MemberExpression" && !v.callee.computed ? v.callee.property : v.callee;
+	const name = callee.type === "Identifier" ? callee.name : void 0;
+	const args = v.arguments;
+	if (name === "fileURLToPath") {
+		const url = args[0];
+		if (url?.type !== "NewExpression") return void 0;
+		const [href, base] = url.arguments;
+		return base?.type === "MemberExpression" && base.object.type === "MetaProperty" && base.property.type === "Identifier" && base.property.name === "url" ? stringLiteralOf(href) : void 0;
+	}
+	if (name !== "resolve" && name !== "join") return void 0;
+	const parts = [];
+	for (const [i, arg] of args.entries()) {
+		if (i === 0 && isRootDir(arg)) continue;
+		const part = stringLiteralOf(arg);
+		if (part === void 0) return void 0;
+		if (name === "resolve" && part.startsWith("/")) parts.length = 0;
+		parts.push(part);
+	}
+	return parts.join("/");
+}
+/** A property's value as a config path (see `pathValueOf`), else undefined. */
 function stringValueOf(p) {
-	const v = unwrapTs(p.value);
-	return v.type === "Literal" && typeof v.value === "string" ? v.value : void 0;
+	return pathValueOf(p.value);
 }
 /**
 * `kit.alias`'s entries in source order. Undefined when the key set cannot be known (see
@@ -2745,7 +3319,7 @@ function findKitAliasesInSvelteConfig(source) {
 * same irregularities available to it.
 */
 function normalizeAliasValue(value) {
-	const posix = value.replace(/\\/g, "/");
+	const posix = value.replace(/\\/g, "/").replace(/^(\.\/)+/, "");
 	return (posix.endsWith("/*") ? posix.slice(0, -2) : posix).replace(/\/+$/, "");
 }
 /**
@@ -2788,6 +3362,57 @@ function resolveKitAliases(viteConfig, svelteConfig) {
 	if (!svelteConfig) return void 0;
 	return compileKitAliases(findKitAliasesInSvelteConfig(svelteConfig.source));
 }
+/** Conditions every Vite build of a Svelte app matches; `types`/`require` never apply to an ESM import. */
+const MATCHED_CONDITIONS = /* @__PURE__ */ new Set([
+	"svelte",
+	"import",
+	"module",
+	"default"
+]);
+const IGNORED_CONDITIONS = /* @__PURE__ */ new Set(["types", "require"]);
+/**
+* The target a package `imports` value resolves to, walking conditions in declaration order as Node
+* does. A condition that depends on the environment (`node`, `browser`, `development`, …) makes the
+* answer unknowable here, so it resolves to nothing rather than to a branch that may not apply.
+*/
+function importTarget(value) {
+	if (typeof value === "string") return value;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	for (const [condition, branch] of Object.entries(value)) {
+		if (IGNORED_CONDITIONS.has(condition)) continue;
+		return MATCHED_CONDITIONS.has(condition) ? importTarget(branch) : void 0;
+	}
+}
+/**
+* `aliases` followed by the project's package.json `imports` entries (`"#lib/*": "./src/lib/*"`),
+* after Kit's own: Vite's alias plugin resolves before Node-style subpath imports. The entries are
+* ordered by Node's precedence — exact keys, then patterns by longest prefix — because the alias
+* resolver takes the first match. Only a project-relative target counts; anything else is skipped,
+* which leaves the specifier unresolved as before.
+*/
+function withPackageImports(aliases, packageJsonSource) {
+	let imports;
+	try {
+		imports = JSON.parse(packageJsonSource ?? "").imports;
+	} catch {
+		return aliases;
+	}
+	if (!imports || typeof imports !== "object") return aliases;
+	const entries = [];
+	for (const [key, raw] of Object.entries(imports)) {
+		const target = importTarget(raw);
+		if (target === void 0 || !target.startsWith("./")) continue;
+		const star = key.endsWith("/*");
+		if (star !== target.endsWith("/*") || key.slice(0, star ? -2 : void 0).includes("*")) continue;
+		entries.push({
+			find: star ? key.slice(0, -2) : key,
+			replacement: normalizeAliasValue(target.slice(2)),
+			match: star ? "contents" : "exact"
+		});
+	}
+	entries.sort((a, b) => a.match === b.match ? a.match === "exact" ? 0 : b.find.length - a.find.length : a.match === "exact" ? -1 : 1);
+	return entries.length > 0 ? [...aliases ?? DEFAULT_KIT_ALIASES, ...entries] : aliases;
+}
 /** Parse a config source to a program, or undefined when it cannot be parsed. */
 function programOf(source, filename) {
 	try {
@@ -2805,7 +3430,33 @@ function findKitPathsBaseInSvelteConfig(source) {
 	const bindings = collectTopLevelBindings(program);
 	const kit = propOf(config, "kit");
 	const kitObj = kit ? unwrapToObjectExpression(kit.value, bindings) : void 0;
-	return kitObj ? basePathOf(kitObj, bindings) : void 0;
+	return kitObj ? basePathOf(kitObj, bindings, constBindings(program, bindings)) : void 0;
+}
+/**
+* `unwrapToObjectExpression`, but only where the literal is the value: a call passing more than one
+* argument (`mergeConfigs(a, b)`) or a spread could make it something else.
+*/
+function knownObject(expr, bindings) {
+	let current = expr;
+	for (let i = 0; i < 4 && current; i++) {
+		const e = unwrapTs(current);
+		if (e.type === "ObjectExpression") return e.properties.some((p) => p.type === "SpreadElement") ? void 0 : e;
+		if (e.type === "Identifier") current = bindings.get(e.name);
+		else if (e.type === "CallExpression" && e.arguments.length === 1) current = e.arguments[0];
+		else return void 0;
+	}
+}
+/** Whether `kit.router.type` is the literal `'hash'` in a config whose value is known. */
+function findKitHashRouterInSvelteConfig(source) {
+	const program = programOf(source, "svelte.config.js");
+	if (!program) return false;
+	const bindings = collectTopLevelBindings(program);
+	const objectAt = (obj, key) => {
+		const p = obj && propOf(obj, key);
+		return p ? knownObject(p.value, bindings) : void 0;
+	};
+	const router = objectAt(objectAt(knownObject(findExportedExpression(program), bindings), "kit"), "router");
+	return stringLiteralOf(router && propOf(router, "type")?.value) === "hash";
 }
 /**
 * Local names bound to `sveltekit` imported from '@sveltejs/kit/vite'. When no such import is
@@ -2838,7 +3489,7 @@ function findKitPathsBaseInViteConfig(source) {
 		if (arg === void 0) return none;
 		const kitConfig = unwrapToObjectExpression(arg, bindings);
 		if (!kitConfig) return { kind: "unresolvable" };
-		const base = basePathOf(kitConfig, bindings);
+		const base = basePathOf(kitConfig, bindings, constBindings(program, bindings));
 		return base ? {
 			kind: "resolved",
 			base
@@ -2868,6 +3519,219 @@ function resolveKitPathsBase(viteConfig, svelteConfig) {
 	} : void 0;
 }
 //#endregion
+//#region src/workspace-packages.ts
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies"
+];
+/**
+* The app's dependencies that link a package of the same repository, name → range: a `workspace:`
+* version range, or a `link:`/`file:` path. A `workspace:` range that renames (`workspace:other@*`)
+* or names a path is left out, since the specifier would not be the package's own name.
+*/
+function declaredLocalPackages(packageJsonSource) {
+	const out = /* @__PURE__ */ new Map();
+	let pkg;
+	try {
+		pkg = JSON.parse(packageJsonSource ?? "");
+	} catch {
+		return out;
+	}
+	for (const field of DEPENDENCY_FIELDS) {
+		const deps = pkg?.[field];
+		if (!deps || typeof deps !== "object") continue;
+		for (const [name, range] of Object.entries(deps)) if (typeof range === "string" && /^(?:workspace:(?:[\^~*\d]|$)|link:|file:)/.test(range)) out.set(name, range);
+	}
+	return out;
+}
+/** The `packages:` globs of a `pnpm-workspace.yaml`, in block (`- 'apps/*'`) or flow (`[a, b]`) form. */
+function pnpmWorkspaceGlobs(yaml) {
+	const out = [];
+	const item = (raw) => {
+		const value = raw.trim().replace(/^(['"])(.*)\1$/, "$2");
+		if (value) out.push(value);
+	};
+	let inPackages = false;
+	for (const line of yaml.split(/\r?\n/)) {
+		if (/^\s*(#|$)/.test(line)) continue;
+		const key = /^packages\s*:\s*(.*)$/.exec(line);
+		if (key) {
+			const flow = /^\[(.*)\]/.exec(key[1].replace(/\s+#.*$/, ""));
+			if (flow) flow[1].split(",").forEach(item);
+			inPackages = !flow;
+			continue;
+		}
+		if (!inPackages) continue;
+		if (/^[^\s-]/.test(line)) break;
+		const entry = /^\s*-\s*(.*?)\s*(?:\s#.*)?$/.exec(line);
+		if (entry) item(entry[1]);
+	}
+	return out;
+}
+/** A root `package.json`'s `workspaces` globs (an array, or `{ packages }`); undefined when it declares none. */
+function packageJsonWorkspaceGlobs(source) {
+	let workspaces;
+	try {
+		workspaces = JSON.parse(source ?? "").workspaces;
+	} catch {
+		return;
+	}
+	const list = Array.isArray(workspaces) ? workspaces : workspaces?.packages;
+	return Array.isArray(list) ? list.filter((g) => typeof g === "string") : void 0;
+}
+/** A package-relative `svelte` field (`./dist/index.js`, `index.js`); undefined when absent or leaving the package. */
+function svelteField(manifest) {
+	let field;
+	try {
+		field = JSON.parse(manifest).svelte;
+	} catch {
+		return;
+	}
+	if (typeof field !== "string" || field.startsWith("/") || /^[A-Za-z]:/.test(field)) return void 0;
+	const rel = field.replace(/^\.\//, "");
+	return rel && !rel.split("/").includes("..") ? rel : void 0;
+}
+/** `dir/rel`, or `dir` itself for an empty `rel`. */
+function inDir(dir, rel) {
+	const tail = normalizeAliasValue(rel);
+	return tail ? `${dir}/${tail}` : dir;
+}
+/**
+* One package's entries, as Node resolves a bare specifier against its `exports`: a key without
+* `*` matches exactly, a `./x/*` key matches the directory's contents (its target may add a suffix
+* after `*`: `./src/*.js`); exact keys come first, then
+* patterns by longest prefix. The condition walk is `importTarget`'s, in declaration order over
+* `svelte`/`import`/`module`/`default`. A target this cannot follow — an environment condition,
+* a `null` exclusion, a `*` mid-pattern or mid-segment, a path leaving the package — stays as an opaque entry so
+* a shorter pattern cannot answer in its place. Without `exports`, the bare name resolves through
+* the `svelte` field and subpaths through the package's file layout.
+*/
+function entriesOf({ name, dir, manifest }) {
+	let exports;
+	try {
+		exports = JSON.parse(manifest).exports;
+	} catch {
+		return [];
+	}
+	if (exports === void 0) {
+		const field = svelteField(manifest);
+		return [...field === void 0 ? [] : [{
+			find: name,
+			replacement: inDir(dir, field),
+			match: "exact",
+			root: dir
+		}], {
+			find: name,
+			replacement: dir,
+			match: "prefix",
+			root: dir
+		}];
+	}
+	const keys = exports && typeof exports === "object" && !Array.isArray(exports) ? Object.keys(exports) : [];
+	const dotted = keys.filter((k) => k.startsWith(".")).length;
+	if (dotted > 0 && dotted < keys.length) return [{
+		find: name,
+		replacement: null,
+		match: "prefix",
+		root: dir
+	}];
+	const subpaths = dotted > 0 ? exports : { ".": exports };
+	const out = [];
+	for (const [key, value] of Object.entries(subpaths)) {
+		const star = key.indexOf("*");
+		const target = importTarget(value);
+		const local = target?.startsWith("./") && !target.split("/").includes("..") ? target.slice(2) : void 0;
+		if (star < 0) {
+			const replacement = local === void 0 || local.includes("*") ? null : inDir(dir, local);
+			out.push({
+				find: name + key.slice(1),
+				replacement,
+				match: "exact",
+				root: dir
+			});
+			continue;
+		}
+		const head = key.slice(1, star);
+		const trailing = star === key.length - 1 && head.endsWith("/");
+		const at = local?.indexOf("*") ?? -1;
+		const follows = trailing && at > 0 && local[at - 1] === "/" && !local.includes("*", at + 1);
+		const suffix = follows ? local.slice(at + 1) : "";
+		out.push({
+			find: name + head.slice(0, head.lastIndexOf("/")),
+			replacement: follows ? inDir(dir, local.slice(0, at - 1)) : null,
+			match: "contents",
+			root: dir,
+			...suffix ? { suffix } : {}
+		});
+	}
+	return out.sort((a, b) => a.match === b.match ? a.match === "exact" ? 0 : b.find.length - a.find.length : a.match === "exact" ? -1 : 1);
+}
+/**
+* `aliases` widened with the app's workspace packages, the way the bundler sees them: an alias
+* whose value points into `node_modules/<package>` names the package's own directory (the link a
+* workspace install creates, readable whether or not it was installed), and every package's
+* `exports` follows the aliases, as Vite resolves a bare specifier only after its alias plugin.
+*/
+function withWorkspacePackages(aliases, packages) {
+	if (packages.length === 0) return aliases;
+	const linked = (entry) => {
+		for (const { name, dir } of packages) {
+			const from = `node_modules/${name}`;
+			const r = entry.replacement;
+			if (r === from || r?.startsWith(`${from}/`)) return {
+				...entry,
+				replacement: dir + r.slice(from.length),
+				root: dir
+			};
+		}
+		return entry;
+	};
+	return [...(aliases ?? DEFAULT_KIT_ALIASES).map(linked), ...packages.flatMap(entriesOf)];
+}
+/**
+* The app's dependencies that an install puts in `node_modules`: every declared name whose range is
+* not a local protocol (`workspace:`, `link:`, `file:`, `portal:`). Those are the workspace
+* resolver's, whose bounds must not be sidestepped through their `node_modules` link.
+*/
+function declaredInstalledPackages(packageJsonSource) {
+	let pkg;
+	try {
+		pkg = JSON.parse(packageJsonSource ?? "");
+	} catch {
+		return [];
+	}
+	const out = /* @__PURE__ */ new Set();
+	for (const field of DEPENDENCY_FIELDS) {
+		const deps = pkg?.[field];
+		if (!deps || typeof deps !== "object") continue;
+		for (const [name, range] of Object.entries(deps)) if (typeof range === "string" && !/^(?:workspace|link|file|portal):/.test(range)) out.add(name);
+	}
+	return [...out];
+}
+function hasSvelteCondition(value) {
+	if (!value || typeof value !== "object") return false;
+	return Object.entries(value).some(([key, branch]) => key === "svelte" || hasSvelteCondition(branch));
+}
+/** Whether a manifest publishes Svelte components: a `svelte` field, or a `svelte` condition in `exports`. */
+function isSveltePackage(manifest) {
+	try {
+		const { svelte, exports } = JSON.parse(manifest);
+		return typeof svelte === "string" || hasSvelteCondition(exports);
+	} catch {
+		return false;
+	}
+}
+/**
+* `aliases` widened with the Svelte packages installed in `node_modules` (`dir` is the textual
+* `node_modules/<name>` path, relative to the app), compiled like workspace packages. Packages that
+* publish no Svelte marker get no entries: nothing they export is a component.
+*/
+function withInstalledPackages(aliases, packages) {
+	const svelte = packages.filter((p) => isSveltePackage(p.manifest));
+	return svelte.length === 0 ? aliases : [...aliases ?? DEFAULT_KIT_ALIASES, ...svelte.flatMap(entriesOf)];
+}
+//#endregion
 //#region src/project-paths.ts
 /**
 * Source-file locations that satisfy the project-scope rules, shared by every
@@ -2886,6 +3750,19 @@ const SITEMAP_SOURCE_PATHS = [
 	"src/routes/sitemap.xml/+server.ts",
 	"src/routes/sitemap.xml/+server.js"
 ];
+/** The `+server` endpoints above, wherever (group) directories nest them — filter with `servesRootFile`. */
+const ROOT_FILE_ENDPOINT_GLOB = "src/routes/**/{robots.txt,sitemap*.xml}/+server.{ts,js}";
+/**
+* Whether a `+server` endpoint serves `/<file>`: (group) directories add no URL segment, and an optional
+* parameter in the name (`sitemap[[page]].xml`) still answers the bare name.
+*/
+function servesRootFile(rel, file) {
+	const segments = rel.split("/");
+	const dot = file.lastIndexOf(".");
+	const optional = new RegExp(`^${file.slice(0, dot)}\\[\\[[^\\]]+\\]\\]\\${file.slice(dot)}$`);
+	const dir = segments.at(-2) ?? "";
+	return segments[0] === "src" && segments[1] === "routes" && (dir === file || optional.test(dir)) && /^\+server\.(ts|js)$/.test(segments.at(-1) ?? "") && segments.slice(2, -2).every((s) => /^\(.+\)$/.test(s));
+}
 /** Vite's own config resolution order — only the first existing file is the one Vite loads. */
 const VITE_CONFIG_FILES = [
 	"vite.config.js",
@@ -2957,7 +3834,7 @@ async function runRules(rules, ctx) {
 	}));
 	const results = [];
 	const failedRules = [];
-	for (const outcome of perRule) if (Array.isArray(outcome)) results.push(...outcome);
+	for (const outcome of perRule) if (Array.isArray(outcome)) for (const r of outcome) results.push(r);
 	else failedRules.push(outcome);
 	return {
 		results,
@@ -3129,7 +4006,7 @@ function formatConsoleReport(results, config, options = {}) {
 		}
 		lines.push("");
 	}
-	if (options.byRoute) lines.push(...byRouteTree(p, results, config, options.verbose ?? false));
+	if (options.byRoute) for (const line of byRouteTree(p, results, config, options.verbose ?? false)) lines.push(line);
 	if (options.verbose && summary.dynamic > 0) lines.push(p.dim("↯ = set dynamically (verified at runtime)."));
 	return lines.join("\n").replace(/\n+$/, "\n");
 }
@@ -3156,7 +4033,7 @@ function formatAgentReport(results, config) {
 		if (!groups.has(key)) groups.set(key, []);
 		groups.get(key).push(r);
 	}
-	const groupSeverity = (rs) => Math.min(...rs.map((r) => SEVERITY_RANK[effectiveSeverity(r, config)]));
+	const groupSeverity = (rs) => rs.reduce((min, r) => Math.min(min, SEVERITY_RANK[effectiveSeverity(r, config)]), Infinity);
 	const orderedGroups = [...groups.entries()].sort((a, b) => groupSeverity(a[1]) - groupSeverity(b[1]) || a[0].localeCompare(b[0]));
 	for (const [loc, rs] of orderedGroups) {
 		rs.sort((x, y) => SEVERITY_RANK[effectiveSeverity(x, config)] - SEVERITY_RANK[effectiveSeverity(y, config)] || x.id.localeCompare(y.id));
@@ -3992,4 +4869,4 @@ function formatHtmlReport(results, config, meta) {
 	return buildHtmlDocument(buildJsonReport(results, config, meta), meta);
 }
 //#endregion
-export { ANCESTRY_DEPENDENT_TAGS, APP_SCRIPT, ASIDE_DEMOTING_TAGS, CHILD_NODE_KEYS, IDREF_ATTRS, NAMING_ATTRS, ROBOTS_SOURCE_PATHS, SEARCH_RESULT_RULES, SECTIONING_TAGS, SITEMAP_SOURCE_PATHS, SVELTE_CONFIG_FILES, VITE_CONFIG_FILES, a11yAbbrTitle, a11yAccessibleName, a11yAriaHiddenFocus, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoAccesskey, a11yNoAutofocus, a11yNoDuplicateDt, a11yNoMissingIdRef, a11yPatternTitle, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, addFactsDirectives, allRules, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentFacts, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, correctnessBasePathNavigation, correctnessCheckableBindValue, correctnessEachIndexKey, correctnessEachKey, correctnessEffectAsDerived, correctnessEffectAsOnMount, correctnessInstanceBrowserGlobal, correctnessNonreactiveBuiltinState, correctnessOrphanEffect, correctnessOrphanLifecycle, correctnessPropMutation, correctnessServerBrowserGlobal, correctnessStalePropDerivation, correctnessUnmutatedState, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, escapeHtml, explainRule, findAttr, findMinifyDisabled, foldOccurrences, formatAgentReport, formatConsoleReport, formatFailedRuleWarning, formatGithubReport, formatHtmlReport, formatJsonReport, formatMarkdownReport, formatSarifReport, hasFailureAtOrAbove, isClassicScriptType, isPenalized, isPlainObject, isTopFragment, lineOf, noColorPalette, parseComponentFacts, parseSvelte, performanceFontPreloadCrossorigin, performanceHeavyImport, performanceIframeLoading, performanceImageDimensions, performanceImageLoadingHint, performanceLcpImage, performanceLoadWaterfall, performanceMinifyDisabled, performanceNamespaceImport, performancePreconnect, performancePreloadMissingAs, performanceRenderBlockingScript, performanceResponsiveImage, performanceSequentialAwaits, performanceStateRaw, renderAppShell, resolveKitAliases, resolveKitPathsBase, resolveLandmark, resolveRepoLocalPath, resolveRuleOptions, runAnalysis, runRules, safeHref, scoreColor, securityHandlerStateWrite, securityJavascriptUrl, securityRawHtml, securityServerModuleState, securitySharedStateImport, selectRules, seoCanonicalUrl, seoCharset, seoDescriptionLength, seoDescriptionPresence, seoDuplicateDescription, seoDuplicateTitle, seoHeadingLevelSkip, seoHreflang, seoHtmlLang, seoImageAlt, seoIndexability, seoJsonLd, seoJsonLdDateFormat, seoJsonLdDeprecatedType, seoJsonLdPlaceholder, seoJsonLdRelativeUrl, seoJsonLdRequiredProps, seoJsonLdValidity, seoOgDescription, seoOgImage, seoOgTitle, seoOgUrl, seoRobotsTxt, seoSingleH1, seoSitemapInRobots, seoSitemapXml, seoSsrDisabled, seoTitleLength, seoTitlePresence, seoTwitterCard, seoViewport, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, terminalSafe, textFromNodes, unknownDirectiveIds, validateRuleSetting, valueFromNodes, withFailedRulesOff, withIndexableOff, withReadLimit };
+export { ANCESTRY_DEPENDENT_TAGS, APP_SCRIPT, ASIDE_DEMOTING_TAGS, CHILD_NODE_KEYS, IDREF_ATTRS, NAMING_ATTRS, ROBOTS_SOURCE_PATHS, ROOT_FILE_ENDPOINT_GLOB, SEARCH_RESULT_RULES, SECTIONING_TAGS, SITEMAP_SOURCE_PATHS, SVELTE_CONFIG_FILES, VITE_CONFIG_FILES, a11yAbbrTitle, a11yAccessibleName, a11yAriaHiddenFocus, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoAccesskey, a11yNoAutofocus, a11yNoDuplicateDt, a11yNoMissingIdRef, a11yPatternTitle, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, addFactsDirectives, allRules, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentConstantLists, collectComponentFacts, collectConstantListExports, collectFalseExports, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, correctnessBasePathNavigation, correctnessCheckableBindValue, correctnessEachIndexKey, correctnessEachKey, correctnessEffectAsDerived, correctnessEffectAsOnMount, correctnessInstanceBrowserGlobal, correctnessNonreactiveBuiltinState, correctnessOrphanEffect, correctnessOrphanLifecycle, correctnessPropMutation, correctnessServerBrowserGlobal, correctnessStalePropDerivation, correctnessUnmutatedState, declaredInstalledPackages, declaredLocalPackages, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, escapeHtml, explainRule, findAttr, findKitHashRouterInSvelteConfig, findMinifyDisabled, foldOccurrences, formatAgentReport, formatConsoleReport, formatFailedRuleWarning, formatGithubReport, formatHtmlReport, formatJsonReport, formatJsonReportChunks, formatMarkdownReport, formatSarifReport, hasFailureAtOrAbove, hasRel, isClassicScriptType, isPenalized, isPlainObject, isSvgSrc, isTopFragment, layoutNeverRenders, lineOf, noColorPalette, packageJsonWorkspaceGlobs, pageRendersOnlyWhenBuilding, parseComponentFacts, parseModuleProgram, parseSvelte, performanceFontPreloadCrossorigin, performanceHeavyImport, performanceIframeLoading, performanceImageDimensions, performanceImageLoadingHint, performanceLcpImage, performanceLoadWaterfall, performanceMinifyDisabled, performanceNamespaceImport, performancePreconnect, performancePreloadMissingAs, performanceRenderBlockingScript, performanceResponsiveImage, performanceSequentialAwaits, performanceStateRaw, pnpmWorkspaceGlobs, renderAppShell, resolveKitAliases, resolveKitPathsBase, resolveLandmark, resolveRepoLocalPath, resolveRuleOptions, routeNeverSsr, runAnalysis, runRules, safeHref, scoreColor, securityHandlerStateWrite, securityJavascriptUrl, securityRawHtml, securityServerModuleState, securitySharedStateImport, selectRules, seoCanonicalUrl, seoCharset, seoDescriptionLength, seoDescriptionPresence, seoDuplicateDescription, seoDuplicateTitle, seoHeadingLevelSkip, seoHreflang, seoHtmlLang, seoImageAlt, seoIndexability, seoJsonLd, seoJsonLdDateFormat, seoJsonLdDeprecatedType, seoJsonLdPlaceholder, seoJsonLdRelativeUrl, seoJsonLdRequiredProps, seoJsonLdValidity, seoOgDescription, seoOgImage, seoOgTitle, seoOgUrl, seoRobotsTxt, seoSingleH1, seoSitemapInRobots, seoSitemapXml, seoSsrDisabled, seoTitleLength, seoTitlePresence, seoTwitterCard, seoViewport, servesRootFile, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, terminalSafe, textFromNodes, unknownDirectiveIds, unwrapTs, validateRuleSetting, valueFromNodes, walkEstree, withFailedRulesOff, withIndexableOff, withInstalledPackages, withPackageImports, withReadLimit, withWorkspacePackages };