@svelte-vitals/core 0.27.0 → 0.29.0

package/dist/index.js

@@ -86,9 +86,62 @@ function attrTextOf(attr) {
 }
 
 // src/component-parse.ts
-function isConstantListEach(node) {
-  const expr = node?.expression;
-  return expr?.type === "ArrayExpression" && Array.isArray(expr.elements) && !expr.elements.some((el) => el?.type === "SpreadElement");
+function unwrapTs(expr) {
+  let cur = expr;
+  while (cur.type === "TSSatisfiesExpression" || cur.type === "TSAsExpression" || cur.type === "TSNonNullExpression")
+    cur = cur.expression;
+  return cur;
+}
+function isLengthOnlyArrayCall(expr) {
+  const e = unwrapTs(expr);
+  if (!e) return false;
+  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")
+    );
+  }
+  return false;
+}
+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));
+  }
+  return isLengthOnlyArrayCall(expr);
+}
+function isIndexExpression(expr, index) {
+  const e = unwrapTs(expr);
+  if (e.type === "Identifier") return e.name === index;
+  if (e.type === "CallExpression") {
+    const callee = e.callee;
+    if (callee.type === "Identifier" && (callee.name === "String" || callee.name === "Number") && e.arguments.length === 1) {
+      return isIndexExpression(e.arguments[0], index);
+    }
+    if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "toString" && e.arguments.length === 0) {
+      return isIndexExpression(callee.object, index);
+    }
+    return false;
+  }
+  if (e.type === "TemplateLiteral") {
+    const exprs = e.expressions;
+    if (exprs.length !== 1) return false;
+    const hasText = e.quasis.some((q) => (q.value.cooked ?? q.value.raw) !== "");
+    if (hasText) return false;
+    return isIndexExpression(exprs[0], index);
+  }
+  if (e.type === "BinaryExpression" && e.operator === "+") {
+    const emptyString = (n) => n.type === "Literal" && n.value === "";
+    if (emptyString(e.left)) return isIndexExpression(e.right, index);
+    if (emptyString(e.right)) return isIndexExpression(e.left, index);
+  }
+  return false;
+}
+function isIndexKey(each) {
+  if (typeof each.index !== "string" || each.key == null) return false;
+  return isIndexExpression(each.key, each.index);
 }
 function collectEachBlocks(node, source, acc) {
   if (Array.isArray(node)) {
@@ -96,8 +149,12 @@ function collectEachBlocks(node, source, acc) {
     return;
   }
   if (!node || typeof node !== "object") return;
-  if (node.type === "EachBlock" && node.context != null && !isConstantListEach(node)) {
-    acc.push({ hasKey: node.key != null, line: lineOf(source, node.start) });
+  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);
@@ -188,8 +245,10 @@ function scopeIntroducedNames(node) {
     addBoundNames(node.param, introduced);
   } else if (node.type === "BlockStatement") {
     for (const stmt of node.body ?? []) {
-      if (stmt?.type === "VariableDeclaration" && stmt.kind !== "var") {
+      if (stmt?.type === "VariableDeclaration") {
         for (const d of stmt.declarations ?? []) addBoundNames(d.id, introduced);
+      } else if ((stmt?.type === "FunctionDeclaration" || stmt?.type === "ClassDeclaration") && typeof stmt.id?.name === "string") {
+        introduced.add(stmt.id.name);
       }
     }
   } else if (node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement") {
@@ -199,6 +258,12 @@ function scopeIntroducedNames(node) {
     }
   } else if (node.type === "EachBlock" && node.context) {
     addBoundNames(node.context, introduced);
+    if (typeof node.index === "string") introduced.add(node.index);
+  } else if (node.type === "SnippetBlock") {
+    for (const p of node.parameters ?? []) addBoundNames(p, introduced);
+  } else if (node.type === "AwaitBlock") {
+    if (node.value) addBoundNames(node.value, introduced);
+    if (node.error) addBoundNames(node.error, introduced);
   }
   return introduced;
 }
@@ -216,43 +281,315 @@ function walkScoped(node, visit, shadowed = /* @__PURE__ */ new Set()) {
     walkScoped(node[key], visit, scope);
   }
 }
-function collectStateWrites(root, stateNames, acc) {
+function collectStateWrites(root, stateNames, acc, kinds) {
+  const record = (name, kind) => {
+    acc.add(name);
+    if (kinds) {
+      let set = kinds.get(name);
+      if (!set) kinds.set(name, set = /* @__PURE__ */ new Set());
+      set.add(kind);
+    }
+  };
   walkScoped(root, (n, scope) => {
     const shadowed = (name) => name === void 0 || scope.has(name);
     if (n?.type === "AssignmentExpression") {
       if (n.left?.type === "Identifier" && stateNames.has(n.left.name) && !shadowed(n.left.name)) {
-        acc.add(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)) acc.add(r);
+        if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
       } 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)) acc.add(name);
+        for (const name of bound) if (stateNames.has(name) && !shadowed(name)) record(name, "reassign");
       }
     } else if (n?.type === "UpdateExpression") {
-      const r = rootObjectName(n.argument);
-      if (r && stateNames.has(r) && !shadowed(r)) acc.add(r);
+      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)) acc.add(r);
+      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)) acc.add(r);
+        if (r && stateNames.has(r) && !shadowed(r)) record(r, "mutate");
       }
       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)) acc.add(r);
+        if (r && stateNames.has(r) && !shadowed(r)) record(r, "escape");
+      }
+    }
+  });
+}
+function isDeferredBody(n) {
+  return n?.type === "FunctionDeclaration" || n?.type === "FunctionExpression" || n?.type === "ArrowFunctionExpression";
+}
+function isPlainStateCall(node) {
+  return node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "$state";
+}
+var BUILTIN_STATE_TYPES = /* @__PURE__ */ new Set(["Map", "Set", "Date", "URL", "URLSearchParams"]);
+var BUILTIN_MUTATIONS = {
+  Map: /* @__PURE__ */ new Set(["set", "delete", "clear"]),
+  Set: /* @__PURE__ */ new Set(["add", "delete", "clear"]),
+  Date: /* @__PURE__ */ new Set([
+    "setTime",
+    "setFullYear",
+    "setMonth",
+    "setDate",
+    "setHours",
+    "setMinutes",
+    "setSeconds",
+    "setMilliseconds",
+    "setYear",
+    "setUTCFullYear",
+    "setUTCMonth",
+    "setUTCDate",
+    "setUTCHours",
+    "setUTCMinutes",
+    "setUTCSeconds",
+    "setUTCMilliseconds"
+  ]),
+  URL: /* @__PURE__ */ new Set(),
+  URLSearchParams: /* @__PURE__ */ new Set(["append", "set", "delete", "sort"])
+};
+function collectBuiltinStateSignals(node, candidates, mutated, reassigned, shadowed = /* @__PURE__ */ new Set(), inFunction = false) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectBuiltinStateSignals(child, candidates, mutated, reassigned, shadowed, inFunction);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  const boundary = isDeferredBody(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression";
+  const nextInFunction = inFunction || boundary;
+  const hit = (name) => typeof name === "string" && candidates.has(name) && !scope.has(name) ? name : void 0;
+  if (node.type === "AssignmentExpression") {
+    if (node.left?.type === "Identifier") {
+      const n = hit(node.left.name);
+      const isBareSelfAssign = node.right?.type === "Identifier" && node.right.name === n;
+      if (n && !isBareSelfAssign) reassigned.add(n);
+    } else if (node.left?.type === "ObjectPattern" || node.left?.type === "ArrayPattern") {
+      const bound = /* @__PURE__ */ new Set();
+      addBoundNames(node.left, bound);
+      for (const name of bound) {
+        const n = hit(name);
+        if (n) reassigned.add(n);
+      }
+    } else if (node.left?.type === "MemberExpression" && inFunction) {
+      const n = hit(rootObjectName(node.left));
+      if (n && candidates.get(n) === "URL") mutated.add(n);
+    }
+  } else if (node.type === "UpdateExpression" && node.argument?.type === "MemberExpression" && inFunction) {
+    const n = hit(rootObjectName(node.argument));
+    if (n && candidates.get(n) === "URL") mutated.add(n);
+  } else if (node.type === "UnaryExpression" && node.operator === "delete" && inFunction) {
+    const n = hit(rootObjectName(node.argument));
+    if (n && candidates.get(n) === "URL") mutated.add(n);
+  } else if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && !node.callee.computed && inFunction) {
+    const method = node.callee.property?.name;
+    if (typeof method === "string") {
+      if (node.callee.object?.type === "Identifier") {
+        const n = hit(node.callee.object.name);
+        if (n && BUILTIN_MUTATIONS[candidates.get(n)]?.has(method)) mutated.add(n);
+      } else if (node.callee.object?.type === "MemberExpression") {
+        const n = hit(rootObjectName(node.callee));
+        if (n && candidates.get(n) === "URL" && BUILTIN_MUTATIONS.URLSearchParams.has(method)) mutated.add(n);
+      }
+    }
+  }
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    collectBuiltinStateSignals(node[key], candidates, mutated, reassigned, scope, nextInFunction);
+  }
+}
+function collectPatternAliasRefs(node, names, acc, scope, ownRhs) {
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  if (node.type === "Identifier") return;
+  if (node.type === "ObjectPattern") {
+    for (const prop of node.properties ?? []) {
+      if (prop?.type === "RestElement") {
+        collectPatternAliasRefs(prop.argument, names, acc, scope, ownRhs);
+      } else if (prop?.type === "Property") {
+        if (prop.computed) collectAliasRefs(prop.key, names, acc, scope, ownRhs);
+        collectPatternAliasRefs(prop.value, names, acc, scope, ownRhs);
+      }
+    }
+    return;
+  }
+  if (node.type === "ArrayPattern") {
+    for (const el of node.elements ?? []) collectPatternAliasRefs(el, names, acc, scope, ownRhs);
+    return;
+  }
+  if (node.type === "AssignmentPattern") {
+    collectPatternAliasRefs(node.left, names, acc, scope, ownRhs);
+    collectAliasRefs(node.right, names, acc, scope, ownRhs);
+    return;
+  }
+  if (node.type === "RestElement") {
+    collectPatternAliasRefs(node.argument, names, acc, scope, ownRhs);
+  }
+}
+function collectAliasRefs(node, names, acc, shadowed = /* @__PURE__ */ new Set(), ownRhs = null) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectAliasRefs(child, names, acc, shadowed, ownRhs);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  if (node.type === "AssignmentExpression") {
+    const lhsIsCandidate = node.left?.type === "Identifier" && names.has(node.left.name) && !scope.has(node.left.name);
+    if (!lhsIsCandidate) collectAliasRefs(node.left, names, acc, scope, null);
+    collectAliasRefs(node.right, names, acc, scope, lhsIsCandidate ? node.left.name : null);
+    return;
+  }
+  if (node.type === "VariableDeclarator") {
+    collectPatternAliasRefs(node.id, names, acc, scope, ownRhs);
+    if (node.init) collectAliasRefs(node.init, names, acc, scope, ownRhs);
+    return;
+  }
+  if (node.type === "Identifier" && names.has(node.name) && !scope.has(node.name) && node.name !== ownRhs) {
+    acc.add(node.name);
+    return;
+  }
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    if (node.type === "MemberExpression" && key === "property" && !node.computed) continue;
+    if (node.type === "Property" && key === "key" && !node.computed) continue;
+    collectAliasRefs(node[key], names, acc, scope, ownRhs);
+  }
+}
+function collectFragmentAliasRefs(node, names, acc, shadowed = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectFragmentAliasRefs(child, names, acc, shadowed);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  if (isDeferredBody(node)) {
+    const introduced2 = scopeIntroducedNames(node);
+    const scope2 = introduced2.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced2]) : shadowed;
+    collectAliasRefs(node.body, names, acc, scope2, null);
+    return;
+  }
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  if (Array.isArray(node.attributes)) collectFragmentAliasRefs(node.attributes, names, acc, scope);
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key) || key === "attributes") continue;
+    collectFragmentAliasRefs(node[key], names, acc, scope);
+  }
+}
+function collectEachContextTaint(node, names, acc, shadowed = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectEachContextTaint(child, names, acc, shadowed);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  if (node.type === "EachBlock") {
+    const expr = unwrapTs(node.expression);
+    const target = expr?.type === "Identifier" ? expr.name : expr?.type === "MemberExpression" ? rootObjectName(expr) : void 0;
+    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 (ctxNames.size > 0) {
+        const union = /* @__PURE__ */ new Set();
+        const kinds = /* @__PURE__ */ new Map();
+        collectStateWrites(node.body, ctxNames, union, kinds);
+        collectTemplateEscapes(node.body, ctxNames, union, kinds);
+        const dirty = [...union].some((n) => {
+          const k = kinds.get(n);
+          return !k || [...k].some((kind) => kind !== "reassign");
+        });
+        if (dirty) acc.add(target);
       }
     }
+  }
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    collectEachContextTaint(node[key], names, acc, scope);
+  }
+}
+function refsNamesEagerly(node, names, shadowed = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) return node.some((c) => refsNamesEagerly(c, names, shadowed));
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return false;
+  if (isDeferredBody(node)) return false;
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  if (node.type === "Identifier" && names.has(node.name) && !scope.has(node.name)) return true;
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    if (node.type === "MemberExpression" && key === "property" && !node.computed) continue;
+    if (node.type === "Property" && key === "key" && !node.computed) continue;
+    if (refsNamesEagerly(node[key], names, scope)) return true;
+  }
+  return false;
+}
+function containsCallLike(node) {
+  let found = false;
+  walkEstree(node, (n) => {
+    if (n?.type === "CallExpression" || n?.type === "NewExpression" || n?.type === "AwaitExpression") found = true;
   });
+  return found;
+}
+function collectFragmentRefs(node, names, acc, shadowed = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    for (const c of node) collectFragmentRefs(c, names, acc, shadowed);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  if (isDeferredBody(node)) return;
+  const introduced = scopeIntroducedNames(node);
+  const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+  if (node.type === "Identifier" && names.has(node.name) && !scope.has(node.name)) acc.add(node.name);
+  if (node.type === "EachBlock" || node.type === "AwaitBlock") {
+    collectFragmentRefs(node.expression, names, acc, shadowed);
+    for (const key of Object.keys(node)) {
+      if (WALK_IGNORED_KEYS.has(key) || key === "expression") continue;
+      collectFragmentRefs(node[key], names, acc, scope);
+    }
+    return;
+  }
+  if (Array.isArray(node.attributes)) collectFragmentRefs(node.attributes, names, acc, scope);
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key) || key === "attributes") continue;
+    if (node.type === "MemberExpression" && key === "property" && !node.computed) continue;
+    if (node.type === "Property" && key === "key" && !node.computed) continue;
+    collectFragmentRefs(node[key], names, acc, scope);
+  }
+}
+function collectStalePropCandidates(program, propNames, source) {
+  const out = [];
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "VariableDeclaration") continue;
+    for (const d of stmt.declarations ?? []) {
+      if (d?.id?.type !== "Identifier" || !d.init) continue;
+      if (containsCallLike(d.init)) continue;
+      if (!refsNamesEagerly(d.init, propNames)) continue;
+      out.push({ name: d.id.name, line: lineOf(source, d.start) });
+    }
+  }
+  return out;
 }
 var COMPONENT_LIKE_TYPES = /* @__PURE__ */ new Set(["Component", "SvelteComponent", "SvelteSelf"]);
-function collectTemplateEscapes(node, stateNames, acc) {
+function collectTemplateEscapes(node, stateNames, acc, kinds) {
+  const record = (name) => {
+    acc.add(name);
+    if (kinds) {
+      let set = kinds.get(name);
+      if (!set) kinds.set(name, set = /* @__PURE__ */ new Set());
+      set.add("escape");
+    }
+  };
   if (Array.isArray(node)) {
-    for (const c of node) collectTemplateEscapes(c, stateNames, acc);
+    for (const c of node) collectTemplateEscapes(c, stateNames, acc, kinds);
     return;
   }
   if (!node || typeof node !== "object" || typeof node.type !== "string") return;
@@ -260,16 +597,36 @@ function collectTemplateEscapes(node, stateNames, acc) {
     for (const attr of node.attributes) {
       if (attr?.type === "BindDirective") {
         const r = rootObjectName(attr.expression);
-        if (r && stateNames.has(r)) acc.add(r);
+        if (r && stateNames.has(r)) record(r);
       } else if (COMPONENT_LIKE_TYPES.has(node.type)) {
         walkEstree(attr, (m) => {
-          if (m?.type === "Identifier" && stateNames.has(m.name)) acc.add(m.name);
+          if (m?.type === "Identifier" && stateNames.has(m.name)) record(m.name);
+        });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectTemplateEscapes(node[key], stateNames, acc, kinds);
+  }
+}
+var DIRECTIVE_ESCAPE_TYPES = /* @__PURE__ */ new Set(["UseDirective", "TransitionDirective", "AnimateDirective"]);
+function collectDirectiveEscapes(node, names, acc) {
+  if (Array.isArray(node)) {
+    for (const c of node) collectDirectiveEscapes(c, names, acc);
+    return;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+  if (Array.isArray(node.attributes)) {
+    for (const attr of node.attributes) {
+      if (DIRECTIVE_ESCAPE_TYPES.has(attr?.type) && attr.expression) {
+        walkEstree(attr.expression, (m) => {
+          if (m?.type === "Identifier" && names.has(m.name)) acc.add(m.name);
         });
       }
     }
   }
   for (const key of CHILD_NODE_KEYS) {
-    if (key in node) collectTemplateEscapes(node[key], stateNames, acc);
+    if (key in node) collectDirectiveEscapes(node[key], names, acc);
   }
 }
 var RUNE_NAMES = /* @__PURE__ */ new Set(["$state", "$derived", "$effect", "$props", "$bindable", "$inspect", "$host"]);
@@ -341,7 +698,7 @@ function isPropsCall(node) {
 function isBindableCall(node) {
   return node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "$bindable";
 }
-function collectNonBindableProps(program) {
+function collectPropNames(program, includeBindable) {
   const names = /* @__PURE__ */ new Set();
   let seen = 0;
   let ambiguous = false;
@@ -361,7 +718,8 @@ function collectNonBindableProps(program) {
         addBoundNames(p.argument, names);
       } else if (p?.type === "Property") {
         if (p.value?.type === "AssignmentPattern") {
-          if (!isBindableCall(p.value.right) && p.value.left?.type === "Identifier") names.add(p.value.left.name);
+          if ((includeBindable || !isBindableCall(p.value.right)) && p.value.left?.type === "Identifier")
+            names.add(p.value.left.name);
         } else if (p.value?.type === "Identifier") {
           names.add(p.value.name);
         }
@@ -370,6 +728,16 @@ function collectNonBindableProps(program) {
   });
   return ambiguous || seen > 1 ? /* @__PURE__ */ new Set() : names;
 }
+function collectLegacyPropNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ExportNamedDeclaration" || stmt.declaration?.type !== "VariableDeclaration") continue;
+    for (const d of stmt.declaration.declarations ?? []) {
+      if (d?.id?.type === "Identifier") names.add(d.id.name);
+    }
+  }
+  return names;
+}
 var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "push",
   "pop",
@@ -443,15 +811,20 @@ function collectNamespaceImports(program, source, acc) {
     }
   });
 }
-var JS_DIRECTIVE = /^\s*\/\/\s*svelte-vitals-disable-next-line(?:\s+([A-Za-z]+\d+(?:\s*,\s*[A-Za-z]+\d+)*))?\s*$/;
-var HTML_DIRECTIVE = /^\s*<!--\s*svelte-vitals-disable-next-line(?:\s+([A-Za-z]+\d+(?:\s*,\s*[A-Za-z]+\d+)*))?\s*-->\s*$/;
+var RULE_ID_RE = "[a-z]+\\/[a-z][a-z0-9-]*";
+var JS_DIRECTIVE = new RegExp(
+  `^\\s*//\\s*svelte-vitals-disable-next-line(?:\\s+(${RULE_ID_RE}(?:\\s*,\\s*${RULE_ID_RE})*))?\\s*$`
+);
+var HTML_DIRECTIVE = new RegExp(
+  `^\\s*<!--\\s*svelte-vitals-disable-next-line(?:\\s+(${RULE_ID_RE}(?:\\s*,\\s*${RULE_ID_RE})*))?\\s*-->\\s*$`
+);
 function collectSuppressions(source) {
   const out = [];
   const lines = source.split("\n");
   lines.forEach((line, i) => {
     const m = JS_DIRECTIVE.exec(line) ?? HTML_DIRECTIVE.exec(line);
     if (!m) return;
-    const ruleIds = m[1]?.split(",").map((s) => s.trim().toUpperCase());
+    const ruleIds = m[1]?.split(",").map((s) => s.trim());
     out.push({ line: i + 2, ruleIds });
   });
   return out;
@@ -807,6 +1180,9 @@ function parseModuleFacts(source, filename) {
     namespaceImports: [],
     constableStates: [],
     mutatedProps: [],
+    stalePropDerivations: [],
+    rawableStates: [],
+    nonreactiveBuiltinStates: [],
     suppressions: collectSuppressions(source),
     orphanEffects,
     orphanLifecycleCalls,
@@ -842,15 +1218,42 @@ function parseComponentFacts(source, filename) {
   const effects = [];
   const constableStates = [];
   const mutatedProps = [];
+  const stalePropDerivations = [];
+  const rawableStates = [];
+  const nonreactiveBuiltinStates = [];
   let propCount = 0;
   const program = ast.instance?.content;
   if (program) {
     collectImportSources(program, source, importSpans);
     collectNamespaceImports(program, source, namespaceImports);
     propCount = countProps(program);
-    const nonBindableProps = collectNonBindableProps(program);
-    collectPropMutations(program, nonBindableProps, source, mutatedProps);
-    if (ast.fragment) collectPropMutations(ast.fragment, nonBindableProps, source, mutatedProps);
+    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);
+    for (const m of rawMutations) mutatedProps.push(legacyPropNames.has(m.name) ? { ...m, legacy: true } : m);
+    const allPropNames = /* @__PURE__ */ new Set([...collectPropNames(program, true), ...legacyPropNames]);
+    if (allPropNames.size > 0) {
+      const candidates = collectStalePropCandidates(program, allPropNames, source);
+      if (candidates.length > 0) {
+        const candidateNames = new Set(candidates.map((c) => c.name));
+        const disqualified = /* @__PURE__ */ new Set();
+        collectStateWrites(program, candidateNames, disqualified);
+        if (ast.fragment) {
+          collectStateWrites(ast.fragment, candidateNames, disqualified);
+          collectTemplateEscapes(ast.fragment, candidateNames, disqualified);
+        }
+        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 } : c);
+          }
+        }
+      }
+    }
     const stateNames = /* @__PURE__ */ new Set();
     const reactiveNames = /* @__PURE__ */ new Set();
     const stateDecls = [];
@@ -878,10 +1281,69 @@ function parseComponentFacts(source, filename) {
     if (ast.fragment) {
       collectStateWrites(ast.fragment, stateNames, writtenOrEscaped);
       collectTemplateEscapes(ast.fragment, stateNames, writtenOrEscaped);
+      collectDirectiveEscapes(ast.fragment, stateNames, writtenOrEscaped);
     }
     for (const d of stateDecls) {
       if (!writtenOrEscaped.has(d.name)) constableStates.push(d);
     }
+    const rawableCandidates = [];
+    for (const stmt of program.body ?? []) {
+      if (stmt?.type !== "VariableDeclaration") continue;
+      for (const d of stmt.declarations ?? []) {
+        if (d?.id?.type !== "Identifier" || !d.init || !isPlainStateCall(d.init)) continue;
+        const arg = unwrapTs(d.init.arguments?.[0]);
+        if (arg?.type === "ObjectExpression" || arg?.type === "ArrayExpression") {
+          rawableCandidates.push({ name: d.id.name, line: lineOf(source, d.start) });
+        }
+      }
+    }
+    if (rawableCandidates.length > 0) {
+      const candNames = new Set(rawableCandidates.map((c) => c.name));
+      const union = /* @__PURE__ */ new Set();
+      const kinds = /* @__PURE__ */ new Map();
+      collectStateWrites(program, candNames, union, kinds);
+      if (ast.fragment) {
+        collectStateWrites(ast.fragment, candNames, union, kinds);
+        collectTemplateEscapes(ast.fragment, candNames, union, kinds);
+      }
+      const aliasEscapes = /* @__PURE__ */ new Set();
+      collectAliasRefs(program, candNames, aliasEscapes);
+      const eachTaint = /* @__PURE__ */ new Set();
+      if (ast.fragment) {
+        collectFragmentAliasRefs(ast.fragment, candNames, aliasEscapes);
+        collectDirectiveEscapes(ast.fragment, candNames, aliasEscapes);
+        collectEachContextTaint(ast.fragment, candNames, eachTaint);
+      }
+      for (const c of rawableCandidates) {
+        const k = kinds.get(c.name);
+        const reassigned = k?.has("reassign") ?? false;
+        const dirty = k !== void 0 && [...k].some((kind) => kind !== "reassign") || aliasEscapes.has(c.name) || eachTaint.has(c.name);
+        if (reassigned && !dirty) rawableStates.push(c);
+      }
+    }
+    const builtinCandidates = /* @__PURE__ */ new Map();
+    for (const stmt of program.body ?? []) {
+      if (stmt?.type !== "VariableDeclaration") continue;
+      for (const d of stmt.declarations ?? []) {
+        if (d?.id?.type !== "Identifier" || !d.init || !isPlainStateCall(d.init)) continue;
+        const arg = unwrapTs(d.init.arguments?.[0]);
+        if (arg?.type === "NewExpression" && arg.callee?.type === "Identifier" && BUILTIN_STATE_TYPES.has(arg.callee.name)) {
+          builtinCandidates.set(d.id.name, { type: arg.callee.name, line: lineOf(source, d.start) });
+        }
+      }
+    }
+    if (builtinCandidates.size > 0) {
+      const types = new Map([...builtinCandidates].map(([n, meta]) => [n, meta.type]));
+      const mutatedBuiltins = /* @__PURE__ */ new Set();
+      const reassignedBuiltins = /* @__PURE__ */ new Set();
+      collectBuiltinStateSignals(program, types, mutatedBuiltins, reassignedBuiltins);
+      if (ast.fragment) collectBuiltinStateSignals(ast.fragment, types, mutatedBuiltins, reassignedBuiltins);
+      for (const [name, meta] of builtinCandidates) {
+        if (mutatedBuiltins.has(name) && !reassignedBuiltins.has(name)) {
+          nonreactiveBuiltinStates.push({ name, type: meta.type, line: meta.line });
+        }
+      }
+    }
     let moduleExtra;
     if (moduleProgram) {
       const moduleBrowserImports = collectBrowserGuardImports(moduleProgram);
@@ -907,6 +1369,9 @@ function parseComponentFacts(source, filename) {
     namespaceImports,
     constableStates,
     mutatedProps,
+    stalePropDerivations,
+    rawableStates,
+    nonreactiveBuiltinStates,
     orphanEffects,
     orphanLifecycleCalls,
     browserGlobalRefs,
@@ -930,6 +1395,9 @@ function emptyComponentFacts(file) {
     namespaceImports: [],
     constableStates: [],
     mutatedProps: [],
+    stalePropDerivations: [],
+    rawableStates: [],
+    nonreactiveBuiltinStates: [],
     orphanEffects: [],
     orphanLifecycleCalls: [],
     browserGlobalRefs: [],
@@ -966,11 +1434,6 @@ var HANDLER_NAMES = /* @__PURE__ */ new Set([
   "OPTIONS",
   "fallback"
 ]);
-function unwrapTs(expr) {
-  let cur = expr;
-  while (cur?.type === "TSSatisfiesExpression" || cur?.type === "TSAsExpression") cur = cur.expression;
-  return cur;
-}
 function isFunctionNode(n) {
   return n?.type === "FunctionDeclaration" || n?.type === "FunctionExpression" || n?.type === "ArrowFunctionExpression";
 }
@@ -995,102 +1458,201 @@ function addActionsMembers(obj, handlers) {
     if (isFunctionNode(v)) handlers.add(v);
   }
 }
-function resolveAliasHandlerExports(program, bindings, handlers) {
+function forEachNamedExport(program, visit) {
   for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ExportNamedDeclaration" || !stmt.specifiers || stmt.source || stmt.exportKind === "type")
+    if (stmt?.type !== "ExportNamedDeclaration" || !stmt.declaration) continue;
+    const decl = stmt.declaration;
+    if (decl.type === "FunctionDeclaration" && decl.id?.type === "Identifier") {
+      if (visit(decl.id.name, decl, decl)) return;
       continue;
-    for (const s of stmt.specifiers) {
-      if (s?.exportKind === "type" || s?.exported?.type !== "Identifier" || s?.local?.type !== "Identifier") continue;
-      const exportedName = s.exported.name;
-      const resolved = bindings.get(s.local.name);
-      if (HANDLER_NAMES.has(exportedName) && isFunctionNode(resolved)) {
-        handlers.add(resolved);
-      } else if (exportedName === "actions" && resolved?.type === "ObjectExpression") {
-        addActionsMembers(resolved, handlers);
-      }
+    }
+    if (decl.type !== "VariableDeclaration") continue;
+    for (const d of decl.declarations ?? []) {
+      if (d?.id?.type !== "Identifier" || !d.init) continue;
+      if (visit(d.id.name, unwrapTs(d.init), d)) return;
     }
   }
-}
-function resolveAliasStartupExports(program, bindings, startup) {
+  let bindings;
   for (const stmt of program.body ?? []) {
     if (stmt?.type !== "ExportNamedDeclaration" || !stmt.specifiers || stmt.source || stmt.exportKind === "type")
       continue;
     for (const s of stmt.specifiers) {
       if (s?.exportKind === "type" || s?.exported?.type !== "Identifier" || s?.local?.type !== "Identifier") continue;
-      if (s.exported.name !== "init") continue;
+      bindings ??= collectTopLevelBindings(program);
       const resolved = bindings.get(s.local.name);
-      if (isFunctionNode(resolved)) startup.add(resolved);
+      if (resolved === void 0) continue;
+      if (visit(s.exported.name, resolved, resolved)) return;
     }
   }
 }
 function collectHandlerFunctions(program) {
   const handlers = /* @__PURE__ */ new Set();
-  for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ExportNamedDeclaration" || !stmt.declaration) continue;
-    const decl = stmt.declaration;
-    if (decl.type === "FunctionDeclaration" && decl.id?.type === "Identifier" && HANDLER_NAMES.has(decl.id.name)) {
-      handlers.add(decl);
-      continue;
-    }
-    if (decl.type !== "VariableDeclaration") continue;
-    for (const d of decl.declarations ?? []) {
-      if (d?.id?.type !== "Identifier" || !d.init) continue;
-      const init = unwrapTs(d.init);
-      if (HANDLER_NAMES.has(d.id.name) && isFunctionNode(init)) {
-        handlers.add(init);
-      } else if (d.id.name === "actions" && init?.type === "ObjectExpression") {
-        addActionsMembers(init, handlers);
-      }
-    }
-  }
-  resolveAliasHandlerExports(program, collectTopLevelBindings(program), handlers);
+  forEachNamedExport(program, (name, value) => {
+    if (HANDLER_NAMES.has(name) && isFunctionNode(value)) handlers.add(value);
+    else if (name === "actions" && value?.type === "ObjectExpression") addActionsMembers(value, handlers);
+    return void 0;
+  });
   return handlers;
 }
 function collectStartupFunctions(program) {
   const startup = /* @__PURE__ */ new Set();
-  for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ExportNamedDeclaration" || !stmt.declaration) continue;
-    const decl = stmt.declaration;
-    if (decl.type === "FunctionDeclaration" && decl.id?.type === "Identifier" && decl.id.name === "init") {
-      startup.add(decl);
-      continue;
-    }
-    if (decl.type !== "VariableDeclaration") continue;
-    for (const d of decl.declarations ?? []) {
-      if (d?.id?.type !== "Identifier" || !d.init) continue;
-      const init = unwrapTs(d.init);
-      if (d.id.name === "init" && isFunctionNode(init)) startup.add(init);
-    }
-  }
-  resolveAliasStartupExports(program, collectTopLevelBindings(program), startup);
+  forEachNamedExport(program, (name, value) => {
+    if (name === "init" && isFunctionNode(value)) startup.add(value);
+    return void 0;
+  });
   return startup;
 }
-function hasSsrFalseOptOut(program) {
-  const isFalse = (init) => {
-    const v = unwrapTs(init);
-    return v?.type === "Literal" && v.value === false;
+function findFalseOptOut(program, source, name) {
+  let hit;
+  forEachNamedExport(program, (exported, value, anchor) => {
+    if (exported !== name || value?.type !== "Literal" || value.value !== false) return void 0;
+    hit = { line: lineOf(source, anchor.start) };
+    return true;
+  });
+  return hit;
+}
+function findLoadFunction(program) {
+  let load;
+  forEachNamedExport(program, (name, value) => {
+    if (name !== "load" || !isFunctionNode(value)) return void 0;
+    load = value;
+    return true;
+  });
+  return load;
+}
+function collectAwaits(node, out = []) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectAwaits(child, out);
+    return out;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return out;
+  if (isFunctionNode(node)) return out;
+  if (node.type === "AwaitExpression") out.push(node);
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    collectAwaits(node[key], out);
+  }
+  return out;
+}
+function isParentCall(arg) {
+  const e = unwrapTs(arg);
+  if (e?.type !== "CallExpression") return false;
+  const callee = e.callee;
+  if (callee?.type === "Identifier" && callee.name === "parent") return true;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "parent";
+}
+var BODY_METHODS = /* @__PURE__ */ new Set(["json", "text", "blob", "arrayBuffer", "formData", "bytes"]);
+function isBodyParseCall(arg) {
+  const e = unwrapTs(arg);
+  if (e?.type !== "CallExpression" || e.arguments?.length) return false;
+  const callee = e.callee;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && BODY_METHODS.has(callee.property.name);
+}
+function refsTainted(node, tainted) {
+  let hit = false;
+  const walk = (n, shadowed) => {
+    if (hit) return;
+    if (Array.isArray(n)) {
+      for (const child of n) walk(child, shadowed);
+      return;
+    }
+    if (!n || typeof n !== "object" || typeof n.type !== "string") return;
+    const introduced = scopeIntroducedNames(n);
+    const scope = introduced.size > 0 ? /* @__PURE__ */ new Set([...shadowed, ...introduced]) : shadowed;
+    if (n.type === "Identifier" && tainted.has(n.name) && !scope.has(n.name)) {
+      hit = true;
+      return;
+    }
+    for (const key of Object.keys(n)) {
+      if (WALK_IGNORED_KEYS.has(key)) continue;
+      if (n.type === "MemberExpression" && key === "property" && !n.computed) continue;
+      if (n.type === "Property" && key === "key" && !n.computed) continue;
+      walk(n[key], scope);
+    }
   };
-  for (const stmt of program.body ?? []) {
-    const decl = unwrapExport(stmt);
-    if (decl?.type !== "VariableDeclaration") continue;
-    for (const d of decl.declarations ?? []) {
-      if (d?.id?.type === "Identifier" && d.id.name === "ssr" && d.init && isFalse(d.init)) {
-        if (stmt.type === "ExportNamedDeclaration") return true;
+  walk(node, /* @__PURE__ */ new Set());
+  return hit;
+}
+function collectLoadWaterfalls(program, wrapped) {
+  const dependentLines = [];
+  const independentLines = [];
+  const load = findLoadFunction(program);
+  if (!load?.body || load.body.type !== "BlockStatement") return { dependentLines, independentLines };
+  const line = (start) => Math.max(0, lineOf(wrapped, start) - 1);
+  const tainted = /* @__PURE__ */ new Set();
+  let sawAwaitSite = false;
+  const taintAssignTarget = (left) => {
+    if (left?.type === "MemberExpression") {
+      const root = rootObjectName(left);
+      if (root) tainted.add(root);
+    } else {
+      addBoundNames(left, tainted);
+    }
+  };
+  const taintOnly = (node) => {
+    if (Array.isArray(node)) {
+      for (const child of node) taintOnly(child);
+      return;
+    }
+    if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+    if (isFunctionNode(node)) return;
+    if (node.type === "AssignmentExpression") {
+      if (collectAwaits(node.right).length > 0 || refsTainted(node.right, tainted)) taintAssignTarget(node.left);
+    } else if (node.type === "VariableDeclaration") {
+      for (const d of node.declarations ?? []) {
+        if (d?.id && d.init && (collectAwaits(d.init).length > 0 || refsTainted(d.init, tainted))) {
+          addBoundNames(d.id, tainted);
+        }
       }
     }
-  }
-  const bindings = collectTopLevelBindings(program);
-  for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ExportNamedDeclaration" || !stmt.specifiers || stmt.source || stmt.exportKind === "type")
-      continue;
-    for (const s of stmt.specifiers) {
-      if (s?.exportKind === "type" || s?.exported?.type !== "Identifier" || s?.local?.type !== "Identifier") continue;
-      if (s.exported.name !== "ssr") continue;
-      const resolved = bindings.get(s.local.name);
-      if (resolved?.type === "Literal" && resolved.value === false) return true;
+    for (const key of Object.keys(node)) {
+      if (WALK_IGNORED_KEYS.has(key)) continue;
+      taintOnly(node[key]);
     }
-  }
-  return false;
+  };
+  const processStatements = (body) => {
+    for (const stmt of body ?? []) {
+      if (!stmt) continue;
+      if (stmt.type === "TryStatement") {
+        if (stmt.block?.type === "BlockStatement") processStatements(stmt.block.body);
+        if (stmt.handler) taintOnly(stmt.handler);
+        if (stmt.finalizer) taintOnly(stmt.finalizer);
+        continue;
+      }
+      if (stmt.type === "VariableDeclaration" || stmt.type === "ExpressionStatement" || stmt.type === "ReturnStatement") {
+        const sites = collectAwaits(stmt).filter((a) => !isParentCall(a.argument) && !isBodyParseCall(a.argument));
+        if (sites.length > 0) {
+          const dependent = sites.filter((a) => refsTainted(a.argument, tainted));
+          if (dependent.length > 0) {
+            const anchor = dependent.reduce((m, a) => a.start < m.start ? a : m);
+            dependentLines.push(line(anchor.start));
+          } else if (sawAwaitSite) {
+            const workSites = sites.filter((a) => unwrapTs(a.argument)?.type !== "Identifier");
+            if (workSites.length > 0) {
+              const anchor = workSites.reduce((m, a) => a.start < m.start ? a : m);
+              independentLines.push(line(anchor.start));
+            }
+          }
+          sawAwaitSite = true;
+        }
+        if (stmt.type === "VariableDeclaration") {
+          for (const d of stmt.declarations ?? []) {
+            if (!d?.id || !d.init) continue;
+            if (collectAwaits(d.init).length > 0 || refsTainted(d.init, tainted)) addBoundNames(d.id, tainted);
+          }
+        } else if (stmt.type === "ExpressionStatement") {
+          const expr = unwrapTs(stmt.expression);
+          if (expr?.type === "AssignmentExpression") {
+            if (collectAwaits(expr.right).length > 0 || refsTainted(expr.right, tainted)) taintAssignTarget(expr.left);
+          }
+        }
+      } else {
+        taintOnly(stmt);
+      }
+    }
+  };
+  processStatements(load.body.body);
+  return { dependentLines, independentLines };
 }
 function walkKit(node, handlerFns, startupFns, visit, shadowed = /* @__PURE__ */ new Set(), inFunction = false, inHandler = false, inStartup = false) {
   if (Array.isArray(node)) {
@@ -1187,7 +1749,10 @@ function parseKitModuleFacts(source, filename) {
   const handlerFns = collectHandlerFunctions(program);
   const startupFns = collectStartupFunctions(program);
   const svelteImports = collectSvelteLifecycleImports(program);
-  if (!hasSsrFalseOptOut(program)) {
+  const ssrOptOut = findFalseOptOut(program, wrapped, "ssr");
+  const csrOptOut = findFalseOptOut(program, wrapped, "csr");
+  const waterfalls = collectLoadWaterfalls(program, wrapped);
+  if (!ssrOptOut) {
     const shiftLine = (l) => Math.max(0, l - 1);
     const browserImports = collectBrowserGuardImports(program);
     const guards = /* @__PURE__ */ new Set([...browserImports, ...collectDerivedGuardBindings(program, browserImports)]);
@@ -1287,6 +1852,9 @@ function parseKitModuleFacts(source, filename) {
     runesModuleImports: byLine(runesModuleImports),
     lifecycleCalls: byLine(lifecycleCalls),
     browserGlobalRefs: byLine(browserGlobalRefs),
+    ...ssrOptOut ? { ssrDisabled: { line: Math.max(0, ssrOptOut.line - 1) } } : {},
+    ...csrOptOut ? { csrDisabled: { line: Math.max(0, csrOptOut.line - 1) } } : {},
+    ...waterfalls.dependentLines.length > 0 || waterfalls.independentLines.length > 0 ? { loadWaterfalls: waterfalls } : {},
     suppressions
   };
 }
@@ -1331,7 +1899,82 @@ async function collectKitModuleFacts(rt, cwd) {
   );
 }
 
-// src/project-paths.ts
+// src/vite-config-parse.ts
+function propOf(obj, name) {
+  let found;
+  for (const p of obj.properties) {
+    if (p.type === "SpreadElement") {
+      if (found) found = void 0;
+      continue;
+    }
+    if (p.type !== "Property" || p.computed) continue;
+    if (p.key.type === "Identifier" && p.key.name === name) found = p;
+    else if (p.key.type === "Literal" && p.key.value === name) found = p;
+  }
+  return found;
+}
+function unwrapToObjectExpression(expr, bindings) {
+  let current = expr;
+  for (let i = 0; i < 4 && current; i++) {
+    const e = unwrapTs(current);
+    if (e.type === "ObjectExpression") return e;
+    if (e.type === "Identifier") {
+      current = bindings.get(e.name);
+      continue;
+    }
+    if (e.type === "CallExpression") {
+      current = e.arguments[0];
+      continue;
+    }
+    return void 0;
+  }
+  const final = current ? unwrapTs(current) : void 0;
+  return final?.type === "ObjectExpression" ? final : void 0;
+}
+function findExportedExpression(program) {
+  let exported;
+  for (const stmt of program.body) {
+    if (stmt.type === "ExportDefaultDeclaration") exported = stmt.declaration;
+  }
+  if (exported) return exported;
+  let cjsExported;
+  for (const stmt of program.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (expr.type !== "AssignmentExpression" || expr.operator !== "=") continue;
+    const left = expr.left;
+    if (left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === "module" && left.property.type === "Identifier" && left.property.name === "exports") {
+      cjsExported = expr.right;
+    }
+  }
+  return cjsExported;
+}
+function resolveConfigObject(program) {
+  const exported = findExportedExpression(program);
+  if (!exported) return void 0;
+  return unwrapToObjectExpression(exported, collectTopLevelBindings(program));
+}
+function findMinifyDisabled(source) {
+  let program;
+  let wrapped;
+  try {
+    ({ program, wrapped } = parseModuleProgram(source, "vite.config.ts"));
+  } catch {
+    return void 0;
+  }
+  if (!program) return void 0;
+  const config = resolveConfigObject(program);
+  if (!config) return void 0;
+  const build = propOf(config, "build");
+  const buildValue = build ? unwrapTs(build.value) : void 0;
+  if (buildValue?.type !== "ObjectExpression") return void 0;
+  const minify = propOf(buildValue, "minify");
+  const minifyValue = minify ? unwrapTs(minify.value) : void 0;
+  if (!minify || minifyValue?.type !== "Literal" || minifyValue.value !== false) return void 0;
+  return { line: Math.max(0, lineOf(wrapped, minify.start) - 1) };
+}
+
+// src/project-paths.ts
 var ROBOTS_SOURCE_PATHS = [
   "static/robots.txt",
   "src/routes/robots.txt/+server.ts",
@@ -1360,7 +2003,7 @@ async function runRules(rules, ctx) {
   return perRule.flat();
 }
 
-// src/rules/seo/seo001-title.ts
+// src/rules/seo/title-presence.ts
 var FIX = {
   description: "Add a <title> inside <svelte:head> (a dynamic title is fine).",
   snippet: "<svelte:head>\n  <title>{data.title}</title>\n</svelte:head>",
@@ -1378,8 +2021,8 @@ function messageFor(detection) {
   if (detection.value === "absent") return "Empty <title>";
   return "<title>";
 }
-var seo001Title = {
-  id: "SEO001",
+var seoTitlePresence = {
+  id: "seo/title-presence",
   title: "Title presence",
   category: "seo",
   severity: "critical",
@@ -1390,7 +2033,7 @@ var seo001Title = {
     return ctx.heads.map((head) => {
       const detection = detectTitle(head);
       return {
-        id: "SEO001",
+        id: "seo/title-presence",
         category: "seo",
         severity: "critical",
         detection,
@@ -1398,7 +2041,7 @@ var seo001Title = {
         location: head.file,
         message: messageFor(detection),
         recommendation: "Add a <title> inside <svelte:head>, e.g. <title>{data.title}</title>, or set it via your meta component.",
-        docsUrl: docsUrlFor("SEO001"),
+        docsUrl: docsUrlFor("seo/title-presence"),
         fix: { ...FIX }
       };
     });
@@ -1444,9 +2087,9 @@ function headTagRule(opts) {
   };
 }
 
-// src/rules/seo/seo002-005-008.ts
-var seo002Description = headTagRule({
-  id: "SEO002",
+// src/rules/seo/description-presence.ts
+var seoDescriptionPresence = headTagRule({
+  id: "seo/description-presence",
   title: "Description presence",
   severity: "critical",
   match: (t) => t.kind === "meta" && t.name === "description",
@@ -1459,8 +2102,10 @@ var seo002Description = headTagRule({
     lang: "svelte"
   }
 });
-var seo003Canonical = headTagRule({
-  id: "SEO003",
+
+// src/rules/seo/canonical-url.ts
+var seoCanonicalUrl = headTagRule({
+  id: "seo/canonical-url",
   title: "Canonical URL",
   severity: "warning",
   match: (t) => t.kind === "link" && t.rel === "canonical",
@@ -1473,8 +2118,10 @@ var seo003Canonical = headTagRule({
     lang: "svelte"
   }
 });
-var seo004OgImage = headTagRule({
-  id: "SEO004",
+
+// src/rules/seo/og-image.ts
+var seoOgImage = headTagRule({
+  id: "seo/og-image",
   title: "Open Graph image",
   severity: "warning",
   match: (t) => t.kind === "meta" && t.property === "og:image",
@@ -1487,8 +2134,10 @@ var seo004OgImage = headTagRule({
     lang: "svelte"
   }
 });
-var seo005OgTitle = headTagRule({
-  id: "SEO005",
+
+// src/rules/seo/og-title.ts
+var seoOgTitle = headTagRule({
+  id: "seo/og-title",
   title: "Open Graph title",
   severity: "warning",
   match: (t) => t.kind === "meta" && t.property === "og:title",
@@ -1501,8 +2150,10 @@ var seo005OgTitle = headTagRule({
     lang: "svelte"
   }
 });
-var seo008JsonLd = headTagRule({
-  id: "SEO008",
+
+// src/rules/seo/json-ld.ts
+var seoJsonLd = headTagRule({
+  id: "seo/json-ld",
   title: "JSON-LD structured data",
   severity: "info",
   match: (t) => t.kind === "jsonld",
@@ -1519,93 +2170,99 @@ var seo008JsonLd = headTagRule({
   }
 });
 
-// src/rules/seo/project-rules.ts
+// src/rules/seo/robots-txt.ts
 var present = { presence: "own", value: "static" };
 var absent = { presence: "none", value: "absent" };
-var SEO006_FIX = {
+var FIX2 = {
   description: "Create static/robots.txt (or a src/routes/robots.txt/+server endpoint).",
   snippet: "User-agent: *\nAllow: /\n\nSitemap: https://example.com/sitemap.xml",
   lang: "text"
 };
-var seo006Robots = {
-  id: "SEO006",
+var seoRobotsTxt = {
+  id: "seo/robots-txt",
   title: "robots.txt",
   category: "seo",
   severity: "warning",
   scope: "project",
   rationale: "robots.txt tells crawlers which paths they may fetch and points them to your sitemap; missing it leaves crawl behaviour to defaults.",
-  fix: SEO006_FIX,
+  fix: FIX2,
   async check(ctx) {
     const detection = ctx.project.hasRobotsTxt ? present : absent;
     return [
       {
-        id: "SEO006",
+        id: "seo/robots-txt",
         category: "seo",
         severity: "warning",
         detection,
         message: ctx.project.hasRobotsTxt ? "robots.txt" : "Missing robots.txt",
         recommendation: "Add static/robots.txt or a src/routes/robots.txt/+server endpoint.",
-        docsUrl: docsUrlFor("SEO006"),
-        fix: { ...SEO006_FIX }
+        docsUrl: docsUrlFor("seo/robots-txt"),
+        fix: { ...FIX2 }
       }
     ];
   }
 };
-var SEO007_FIX = {
+
+// src/rules/seo/sitemap-xml.ts
+var present2 = { presence: "own", value: "static" };
+var absent2 = { presence: "none", value: "absent" };
+var FIX3 = {
   description: "Create static/sitemap.xml (or a src/routes/sitemap.xml/+server endpoint).",
   snippet: '<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n  <url><loc>https://example.com/</loc></url>\n</urlset>',
   lang: "xml"
 };
-var seo007Sitemap = {
-  id: "SEO007",
+var seoSitemapXml = {
+  id: "seo/sitemap-xml",
   title: "sitemap.xml",
   category: "seo",
   severity: "warning",
   scope: "project",
   rationale: "A sitemap.xml lists your URLs so search engines can discover and prioritise them, especially pages not well linked internally.",
-  fix: SEO007_FIX,
+  fix: FIX3,
   async check(ctx) {
-    const detection = ctx.project.hasSitemap ? present : absent;
+    const detection = ctx.project.hasSitemap ? present2 : absent2;
     return [
       {
-        id: "SEO007",
+        id: "seo/sitemap-xml",
         category: "seo",
         severity: "warning",
         detection,
         message: ctx.project.hasSitemap ? "sitemap.xml" : "Missing sitemap.xml",
         recommendation: "Add static/sitemap.xml or a src/routes/sitemap.xml/+server endpoint.",
-        docsUrl: docsUrlFor("SEO007"),
-        fix: { ...SEO007_FIX }
+        docsUrl: docsUrlFor("seo/sitemap-xml"),
+        fix: { ...FIX3 }
       }
     ];
   }
 };
-var SEO009_FIX = {
+
+// src/rules/seo/html-lang.ts
+var FIX4 = {
   description: "Set the lang attribute on <html> in src/app.html.",
   snippet: '<html lang="en">',
   lang: "html"
 };
-var seo009HtmlLang = {
-  id: "SEO009",
+var seoHtmlLang = {
+  id: "seo/html-lang",
   title: "<html lang>",
   category: "seo",
   severity: "warning",
   scope: "project",
   rationale: "The <html lang> attribute declares the page language for search engines, screen readers, and translation tools.",
-  fix: SEO009_FIX,
+  fix: FIX4,
   async check(ctx) {
     const detection = ctx.project.htmlLang;
     const message = detection.presence === "none" ? "Missing <html lang>" : detection.value === "absent" ? "Empty <html lang>" : "<html lang>";
     return [
       {
-        id: "SEO009",
+        id: "seo/html-lang",
         category: "seo",
         severity: "warning",
         detection,
         message,
         recommendation: 'Set <html lang="..."> in src/app.html.',
-        docsUrl: docsUrlFor("SEO009"),
-        fix: { ...SEO009_FIX }
+        docsUrl: docsUrlFor("seo/html-lang"),
+        fix: { ...FIX4 }
       }
     ];
   }
@@ -1662,9 +2319,9 @@ function imageRule(opts) {
   };
 }
 
-// src/rules/perf/images.ts
-var perf001ImageDimensions = imageRule({
-  id: "PERF001",
+// src/rules/perf/image-dimensions.ts
+var performanceImageDimensions = imageRule({
+  id: "performance/image-dimensions",
   title: "Image dimensions",
   severity: "warning",
   label: "<img> width/height",
@@ -1677,8 +2334,10 @@ var perf001ImageDimensions = imageRule({
   },
   ok: (img) => img.hasWidth && img.hasHeight
 });
-var perf002ImageLoading = imageRule({
-  id: "PERF002",
+
+// src/rules/perf/image-loading-hint.ts
+var performanceImageLoadingHint = imageRule({
+  id: "performance/image-loading-hint",
   title: "Image loading hint",
   severity: "info",
   label: "<img> loading attribute",
@@ -1691,8 +2350,10 @@ var perf002ImageLoading = imageRule({
   },
   ok: (img) => img.hasLoading
 });
-var perf006ResponsiveImage = imageRule({
-  id: "PERF006",
+
+// src/rules/perf/responsive-image.ts
+var performanceResponsiveImage = imageRule({
+  id: "performance/responsive-image",
   title: "Responsive image",
   severity: "info",
   label: "<img> srcset",
@@ -1759,9 +2420,9 @@ function linkRule(opts) {
   };
 }
 
-// src/rules/perf/resource-hints.ts
-var perf003PreloadAs = linkRule({
-  id: "PERF003",
+// src/rules/perf/preload-missing-as.ts
+var performancePreloadMissingAs = linkRule({
+  id: "performance/preload-missing-as",
   title: "Preload missing as",
   severity: "warning",
   label: "`as` on a preloaded `<link>`",
@@ -1775,8 +2436,10 @@ var perf003PreloadAs = linkRule({
   relevant: (t) => t.rel === "preload",
   ok: (t) => t.hasAs === true
 });
-var perf004FontPreloadCrossorigin = linkRule({
-  id: "PERF004",
+
+// src/rules/perf/font-preload-crossorigin.ts
+var performanceFontPreloadCrossorigin = linkRule({
+  id: "performance/font-preload-crossorigin",
   title: "Font preload missing crossorigin",
   severity: "warning",
   label: "`crossorigin` on a font preload",
@@ -1791,11 +2454,11 @@ var perf004FontPreloadCrossorigin = linkRule({
   ok: (t) => t.hasCrossorigin === true
 });
 
-// src/rules/perf/perf005-lcp-image.ts
-var docsUrl = docsUrlFor("PERF005");
+// src/rules/perf/lcp-image.ts
+var docsUrl = docsUrlFor("performance/lcp-image");
 var recommendation = 'Remove loading="lazy" from the LCP/first image and consider fetchpriority="high" so it loads as early as possible.';
-var perf005LcpImage = {
-  id: "PERF005",
+var performanceLcpImage = {
+  id: "performance/lcp-image",
   title: "LCP image eager loading",
   category: "performance",
   severity: "warning",
@@ -1813,7 +2476,7 @@ var perf005LcpImage = {
       if (!first) continue;
       out.push(
         first.lazy ? {
-          id: "PERF005",
+          id: "performance/lcp-image",
           category: "performance",
           severity: "warning",
           detection: { presence: "none", value: "absent" },
@@ -1823,9 +2486,9 @@ var perf005LcpImage = {
           message: 'First image (likely LCP) is loading="lazy"',
           recommendation,
           docsUrl,
-          fix: { ...perf005LcpImage.fix }
+          fix: { ...performanceLcpImage.fix }
         } : {
-          id: "PERF005",
+          id: "performance/lcp-image",
           category: "performance",
           severity: "warning",
           detection: { presence: "own", value: "static" },
@@ -1840,11 +2503,11 @@ var perf005LcpImage = {
   }
 };
 
-// src/rules/perf/perf007-render-blocking.ts
-var docsUrl2 = docsUrlFor("PERF007");
+// src/rules/perf/render-blocking-script.ts
+var docsUrl2 = docsUrlFor("performance/render-blocking-script");
 var recommendation2 = 'Add defer (or type="module"), or async, to the <script> so it does not block HTML parsing.';
-var perf007RenderBlockingScript = {
-  id: "PERF007",
+var performanceRenderBlockingScript = {
+  id: "performance/render-blocking-script",
   title: "Render-blocking script",
   category: "performance",
   severity: "warning",
@@ -1864,7 +2527,7 @@ var perf007RenderBlockingScript = {
       if (blocking.length > 0) {
         for (const tag of blocking) {
           out.push({
-            id: "PERF007",
+            id: "performance/render-blocking-script",
             category: "performance",
             severity: "warning",
             detection: { presence: "none", value: "absent" },
@@ -1874,12 +2537,12 @@ var perf007RenderBlockingScript = {
             message: `Render-blocking <script>${tag.href ? ` (${tag.href})` : ""} in <head>`,
             recommendation: recommendation2,
             docsUrl: docsUrl2,
-            fix: { ...perf007RenderBlockingScript.fix }
+            fix: { ...performanceRenderBlockingScript.fix }
           });
         }
       } else {
         out.push({
-          id: "PERF007",
+          id: "performance/render-blocking-script",
           category: "performance",
           severity: "warning",
           detection: { presence: "own", value: "static" },
@@ -1894,16 +2557,16 @@ var perf007RenderBlockingScript = {
   }
 };
 
-// src/rules/perf/perf008-preconnect.ts
-var docsUrl3 = docsUrlFor("PERF008");
+// src/rules/perf/preconnect.ts
+var docsUrl3 = docsUrlFor("performance/preconnect");
 var recommendation3 = 'Add <link rel="preconnect"> (or dns-prefetch) for the third-party origin so the connection is set up early.';
 var THIRD_PARTY_ORIGINS = /* @__PURE__ */ new Set(["fonts.googleapis.com", "fonts.gstatic.com"]);
 function hostOf(href) {
   const m = /^(?:https?:)?\/\/([^/?#]+)/i.exec(href);
   return m ? m[1].toLowerCase() : void 0;
 }
-var perf008Preconnect = {
-  id: "PERF008",
+var performancePreconnect = {
+  id: "performance/preconnect",
   title: "Preconnect third-party origin",
   category: "performance",
   severity: "info",
@@ -1930,7 +2593,7 @@ var perf008Preconnect = {
       const missing = [...referenced].filter(([host]) => !covered.has(host));
       if (missing.length === 0) {
         out.push({
-          id: "PERF008",
+          id: "performance/preconnect",
           category: "performance",
           severity: "info",
           detection: { presence: "own", value: "static" },
@@ -1943,7 +2606,7 @@ var perf008Preconnect = {
       }
       for (const [host, file] of missing) {
         out.push({
-          id: "PERF008",
+          id: "performance/preconnect",
           category: "performance",
           severity: "info",
           detection: { presence: "none", value: "absent" },
@@ -1952,7 +2615,7 @@ var perf008Preconnect = {
           message: `Third-party origin ${host} used without a preconnect`,
           recommendation: recommendation3,
           docsUrl: docsUrl3,
-          fix: { ...perf008Preconnect.fix }
+          fix: { ...performancePreconnect.fix }
         });
       }
     }
@@ -1960,28 +2623,28 @@ var perf008Preconnect = {
   }
 };
 
-// src/rules/seo/seo010-015.ts
-var SEO010_FIX = {
+// src/rules/seo/indexability.ts
+var FIX5 = {
   description: 'If this route should be indexed, drop noindex from its <meta name="robots">.',
   snippet: '<svelte:head>\n  <meta name="robots" content="index, follow" />\n</svelte:head>',
   lang: "svelte"
 };
-var seo010Indexability = {
-  id: "SEO010",
+var seoIndexability = {
+  id: "seo/indexability",
   title: "Indexability",
   category: "seo",
   severity: "info",
   scope: "route",
   rationale: "A noindex directive removes the page from search results; an accidental noindex on a public route silently deindexes it.",
-  fix: SEO010_FIX,
+  fix: FIX5,
   async check(ctx) {
-    const docsUrl7 = docsUrlFor("SEO010");
+    const docsUrl7 = docsUrlFor("seo/indexability");
     const out = [];
     for (const head of ctx.heads) {
       const noindexed = head.tags.some((t) => t.kind === "meta" && t.name === "robots" && t.noindex === true);
       if (!noindexed) continue;
       out.push({
-        id: "SEO010",
+        id: "seo/indexability",
         category: "seo",
         severity: "info",
         detection: { presence: "none", value: "absent" },
@@ -1991,14 +2654,16 @@ var seo010Indexability = {
         message: "Route is noindex \u2014 verify this is intentional",
         recommendation: 'If this route should be indexed, remove noindex from its <meta name="robots">.',
         docsUrl: docsUrl7,
-        fix: { ...SEO010_FIX }
+        fix: { ...FIX5 }
       });
     }
     return out;
   }
 };
-var seo011TwitterCard = headTagRule({
-  id: "SEO011",
+
+// src/rules/seo/twitter-card.ts
+var seoTwitterCard = headTagRule({
+  id: "seo/twitter-card",
   title: "Twitter Card",
   severity: "info",
   match: (t) => t.kind === "meta" && t.name === "twitter:card",
@@ -2011,8 +2676,10 @@ var seo011TwitterCard = headTagRule({
     lang: "svelte"
   }
 });
-var seo012OgDescription = headTagRule({
-  id: "SEO012",
+
+// src/rules/seo/og-description.ts
+var seoOgDescription = headTagRule({
+  id: "seo/og-description",
   title: "Open Graph description",
   severity: "warning",
   match: (t) => t.kind === "meta" && t.property === "og:description",
@@ -2025,8 +2692,10 @@ var seo012OgDescription = headTagRule({
     lang: "svelte"
   }
 });
-var seo013OgUrl = headTagRule({
-  id: "SEO013",
+
+// src/rules/seo/og-url.ts
+var seoOgUrl = headTagRule({
+  id: "seo/og-url",
   title: "Open Graph URL",
   severity: "info",
   match: (t) => t.kind === "meta" && t.property === "og:url",
@@ -2039,8 +2708,10 @@ var seo013OgUrl = headTagRule({
     lang: "svelte"
   }
 });
-var seo014Viewport = headTagRule({
-  id: "SEO014",
+
+// src/rules/seo/viewport.ts
+var seoViewport = headTagRule({
+  id: "seo/viewport",
   title: "Viewport",
   severity: "warning",
   match: (t) => t.kind === "meta" && t.name === "viewport",
@@ -2057,37 +2728,43 @@ var seo014Viewport = headTagRule({
     lang: "html"
   }
 });
-var SEO015_FIX = {
+
+// src/rules/seo/sitemap-in-robots.ts
+var FIX6 = {
   description: "Add a Sitemap: line to static/robots.txt.",
   snippet: "User-agent: *\nAllow: /\n\nSitemap: https://example.com/sitemap.xml",
   lang: "text"
 };
-var seo015SitemapInRobots = {
-  id: "SEO015",
+var seoSitemapInRobots = {
+  id: "seo/sitemap-in-robots",
   title: "Sitemap referenced in robots.txt",
   category: "seo",
   severity: "info",
   scope: "project",
   rationale: "A Sitemap: line in robots.txt helps crawlers discover your sitemap; without it discovery relies on manual submission.",
-  fix: SEO015_FIX,
+  fix: FIX6,
   async check(ctx) {
     const { hasRobotsTxt, hasSitemap, robotsReferencesSitemap } = ctx.project;
     if (!(hasRobotsTxt && hasSitemap && robotsReferencesSitemap === false)) return [];
     return [
       {
-        id: "SEO015",
+        id: "seo/sitemap-in-robots",
         category: "seo",
         severity: "info",
         detection: { presence: "none", value: "absent" },
         message: "robots.txt does not reference your sitemap",
         recommendation: "Add a Sitemap: line to static/robots.txt pointing at your sitemap.xml.",
-        docsUrl: docsUrlFor("SEO015"),
-        fix: { ...SEO015_FIX }
+        docsUrl: docsUrlFor("seo/sitemap-in-robots"),
+        fix: { ...FIX6 }
       }
     ];
   }
 };
 
+// src/rules/seo/detection.ts
+var PENALIZED = { presence: "none", value: "absent" };
+var PASS = { presence: "own", value: "static" };
+
 // src/rules/seo/jsonld-engine.ts
 function parseJsonLd(raw) {
   let data;
@@ -2223,65 +2900,9 @@ var REQUIRED_PROPS = {
   VideoObject: ["name", "description", "thumbnailUrl", "uploadDate"],
   LocalBusiness: ["name", "address"]
 };
-
-// src/rules/seo/detection.ts
-var PENALIZED = { presence: "none", value: "absent" };
-var PASS = { presence: "own", value: "static" };
-
-// src/rules/seo/seo016-021.ts
 function jsonldTags(head) {
   return head.tags.filter((t) => t.kind === "jsonld" && typeof t.jsonld === "string");
 }
-var seo016JsonLdValidity = {
-  id: "SEO016",
-  title: "JSON-LD validity",
-  category: "seo",
-  severity: "warning",
-  scope: "route",
-  rationale: "Invalid JSON-LD \u2014 unparseable, or missing @context/@type \u2014 is silently ignored by search engines, so the structured data does nothing.",
-  fix: {
-    description: "Make the JSON-LD valid: parseable JSON with both @context (schema.org) and @type.",
-    snippet: '<svelte:head>\n  <script type="application/ld+json">\n    {"@context":"https://schema.org","@type":"WebPage","name":"\u2026"}\n  </script>\n</svelte:head>',
-    lang: "svelte"
-  },
-  async check(ctx) {
-    const docsUrl7 = docsUrlFor("SEO016");
-    const out = [];
-    for (const head of ctx.heads) {
-      for (const tag of jsonldTags(head)) {
-        const parsed = parseJsonLd(tag.jsonld);
-        let problem;
-        if (!parsed.ok) problem = "JSON-LD is not valid JSON";
-        else if (!parsed.nodes.some((n) => "@context" in n)) problem = "JSON-LD is missing @context";
-        else if (!parsed.nodes.some((n) => typeOf(n).length > 0)) problem = "JSON-LD is missing @type";
-        out.push(
-          problem ? {
-            id: "SEO016",
-            category: "seo",
-            severity: "warning",
-            detection: PENALIZED,
-            route: head.route,
-            location: head.file,
-            message: problem,
-            recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
-            docsUrl: docsUrl7,
-            fix: { ...seo016JsonLdValidity.fix }
-          } : {
-            id: "SEO016",
-            category: "seo",
-            severity: "warning",
-            detection: PASS,
-            route: head.route,
-            message: "JSON-LD validity",
-            recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
-            docsUrl: docsUrl7
-          }
-        );
-      }
-    }
-    return out;
-  }
-};
 function jsonldRule(opts) {
   const docsUrl7 = docsUrlFor(opts.id);
   return {
@@ -2330,8 +2951,62 @@ function jsonldRule(opts) {
     }
   };
 }
-var seo017DeprecatedType = jsonldRule({
-  id: "SEO017",
+
+// src/rules/seo/json-ld-validity.ts
+var seoJsonLdValidity = {
+  id: "seo/json-ld-validity",
+  title: "JSON-LD validity",
+  category: "seo",
+  severity: "warning",
+  scope: "route",
+  rationale: "Invalid JSON-LD \u2014 unparseable, or missing @context/@type \u2014 is silently ignored by search engines, so the structured data does nothing.",
+  fix: {
+    description: "Make the JSON-LD valid: parseable JSON with both @context (schema.org) and @type.",
+    snippet: '<svelte:head>\n  <script type="application/ld+json">\n    {"@context":"https://schema.org","@type":"WebPage","name":"\u2026"}\n  </script>\n</svelte:head>',
+    lang: "svelte"
+  },
+  async check(ctx) {
+    const docsUrl7 = docsUrlFor("seo/json-ld-validity");
+    const out = [];
+    for (const head of ctx.heads) {
+      for (const tag of jsonldTags(head)) {
+        const parsed = parseJsonLd(tag.jsonld);
+        let problem;
+        if (!parsed.ok) problem = "JSON-LD is not valid JSON";
+        else if (!parsed.nodes.some((n) => "@context" in n)) problem = "JSON-LD is missing @context";
+        else if (!parsed.nodes.some((n) => typeOf(n).length > 0)) problem = "JSON-LD is missing @type";
+        out.push(
+          problem ? {
+            id: "seo/json-ld-validity",
+            category: "seo",
+            severity: "warning",
+            detection: PENALIZED,
+            route: head.route,
+            location: head.file,
+            message: problem,
+            recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
+            docsUrl: docsUrl7,
+            fix: { ...seoJsonLdValidity.fix }
+          } : {
+            id: "seo/json-ld-validity",
+            category: "seo",
+            severity: "warning",
+            detection: PASS,
+            route: head.route,
+            message: "JSON-LD validity",
+            recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
+            docsUrl: docsUrl7
+          }
+        );
+      }
+    }
+    return out;
+  }
+};
+
+// src/rules/seo/json-ld-deprecated-type.ts
+var seoJsonLdDeprecatedType = jsonldRule({
+  id: "seo/json-ld-deprecated-type",
   title: "Deprecated structured-data type",
   severity: "info",
   label: "Structured-data type",
@@ -2342,8 +3017,10 @@ var seo017DeprecatedType = jsonldRule({
     return dep ? `@type "${dep}" no longer reliably produces a Google rich result` : void 0;
   }
 });
-var seo018RelativeUrl = jsonldRule({
-  id: "SEO018",
+
+// src/rules/seo/json-ld-relative-url.ts
+var seoJsonLdRelativeUrl = jsonldRule({
+  id: "seo/json-ld-relative-url",
   title: "JSON-LD relative URL",
   severity: "warning",
   label: "JSON-LD URLs",
@@ -2359,8 +3036,10 @@ var seo018RelativeUrl = jsonldRule({
     return bad ? `Relative URL in JSON-LD: "${bad}" \u2014 use an absolute URL` : void 0;
   }
 });
-var seo019DateFormat = jsonldRule({
-  id: "SEO019",
+
+// src/rules/seo/json-ld-date-format.ts
+var seoJsonLdDateFormat = jsonldRule({
+  id: "seo/json-ld-date-format",
   title: "JSON-LD date format",
   severity: "info",
   label: "JSON-LD dates",
@@ -2376,8 +3055,10 @@ var seo019DateFormat = jsonldRule({
     return bad ? `Non-ISO-8601 date in JSON-LD: "${bad}"` : void 0;
   }
 });
-var seo020Placeholder = jsonldRule({
-  id: "SEO020",
+
+// src/rules/seo/json-ld-placeholder.ts
+var seoJsonLdPlaceholder = jsonldRule({
+  id: "seo/json-ld-placeholder",
   title: "JSON-LD placeholder text",
   severity: "info",
   label: "JSON-LD content",
@@ -2388,8 +3069,10 @@ var seo020Placeholder = jsonldRule({
     return bad ? `Placeholder text in JSON-LD: "${bad}"` : void 0;
   }
 });
-var seo021RequiredProps = jsonldRule({
-  id: "SEO021",
+
+// src/rules/seo/json-ld-required-props.ts
+var seoJsonLdRequiredProps = jsonldRule({
+  id: "seo/json-ld-required-props",
   title: "JSON-LD required properties",
   severity: "warning",
   label: "JSON-LD required properties",
@@ -2421,7 +3104,7 @@ function visibleLength(s) {
   return [...segmenter.segment(collapsed)].length;
 }
 
-// src/rules/seo/seo022-023.ts
+// src/rules/seo/length-rule.ts
 function lengthRule(opts) {
   const docsUrl7 = docsUrlFor(opts.id);
   return {
@@ -2467,8 +3150,10 @@ function lengthRule(opts) {
     }
   };
 }
-var seo022TitleLength = lengthRule({
-  id: "SEO022",
+
+// src/rules/seo/title-length.ts
+var seoTitleLength = lengthRule({
+  id: "seo/title-length",
   title: "Title length",
   label: "Title length",
   noun: "Title",
@@ -2478,8 +3163,10 @@ var seo022TitleLength = lengthRule({
   recommendation: "Aim for a title of 30\u201360 characters so it is not truncated in search results.",
   rationale: "A title that is too short wastes the strongest on-page signal; one that is too long is truncated in the SERP."
 });
-var seo023DescriptionLength = lengthRule({
-  id: "SEO023",
+
+// src/rules/seo/description-length.ts
+var seoDescriptionLength = lengthRule({
+  id: "seo/description-length",
   title: "Description length",
   label: "Description length",
   noun: "Description",
@@ -2490,9 +3177,9 @@ var seo023DescriptionLength = lengthRule({
   rationale: "A description that is too short under-uses the SERP snippet; one that is too long is truncated by search engines."
 });
 
-// src/rules/seo/seo024-charset.ts
-var seo024Charset = headTagRule({
-  id: "SEO024",
+// src/rules/seo/charset.ts
+var seoCharset = headTagRule({
+  id: "seo/charset",
   title: "Character encoding",
   severity: "warning",
   match: (t) => t.kind === "meta" && t.name === "charset",
@@ -2507,9 +3194,9 @@ var seo024Charset = headTagRule({
   }
 });
 
-// src/rules/seo/seo025-image-alt.ts
-var seo025ImageAlt = imageRule({
-  id: "SEO025",
+// src/rules/seo/image-alt.ts
+var seoImageAlt = imageRule({
+  id: "seo/image-alt",
   title: "Image alt text",
   category: "seo",
   severity: "warning",
@@ -2524,15 +3211,15 @@ var seo025ImageAlt = imageRule({
   ok: (img) => img.hasAlt
 });
 
-// src/rules/seo/seo026-hreflang.ts
-var docsUrl4 = docsUrlFor("SEO026");
+// src/rules/seo/hreflang.ts
+var docsUrl4 = docsUrlFor("seo/hreflang");
 var recommendation4 = 'Use valid hreflang codes (e.g. "en", "en-US", "x-default") and include an x-default when you have multiple language alternates.';
 var HREFLANG_RE = /^[a-z]{2,3}(-[a-z]{4})?(-([a-z]{2}|\d{3}))?$/i;
 function isValidHreflang(v) {
   return v.toLowerCase() === "x-default" || HREFLANG_RE.test(v);
 }
-var seo026Hreflang = {
-  id: "SEO026",
+var seoHreflang = {
+  id: "seo/hreflang",
   title: "hreflang validity",
   category: "seo",
   severity: "warning",
@@ -2557,7 +3244,7 @@ var seo026Hreflang = {
       }
       out.push(
         problem ? {
-          id: "SEO026",
+          id: "seo/hreflang",
           category: "seo",
           severity: "warning",
           detection: PENALIZED,
@@ -2567,7 +3254,7 @@ var seo026Hreflang = {
           recommendation: recommendation4,
           docsUrl: docsUrl4
         } : {
-          id: "SEO026",
+          id: "seo/hreflang",
           category: "seo",
           severity: "warning",
           detection: PASS,
@@ -2582,11 +3269,11 @@ var seo026Hreflang = {
   }
 };
 
-// src/rules/seo/seo027-heading.ts
-var docsUrl5 = docsUrlFor("SEO027");
+// src/rules/seo/single-h1.ts
+var docsUrl5 = docsUrlFor("seo/single-h1");
 var recommendation5 = "Use exactly one <h1> per page for its main topic; demote extra top-level headings to <h2>+.";
-var seo027Heading = {
-  id: "SEO027",
+var seoSingleH1 = {
+  id: "seo/single-h1",
   title: "Heading hierarchy",
   category: "seo",
   severity: "warning",
@@ -2609,7 +3296,7 @@ var seo027Heading = {
       }
       out.push(
         problem ? {
-          id: "SEO027",
+          id: "seo/single-h1",
           category: "seo",
           severity: "warning",
           detection: PENALIZED,
@@ -2619,7 +3306,7 @@ var seo027Heading = {
           recommendation: recommendation5,
           docsUrl: docsUrl5
         } : {
-          id: "SEO027",
+          id: "seo/single-h1",
           category: "seo",
           severity: "warning",
           detection: PASS,
@@ -2634,7 +3321,7 @@ var seo027Heading = {
   }
 };
 
-// src/rules/seo/seo028-029-uniqueness.ts
+// src/rules/seo/uniqueness-rule.ts
 function uniquenessRule(opts) {
   const docsUrl7 = docsUrlFor(opts.id);
   return {
@@ -2681,8 +3368,10 @@ function uniquenessRule(opts) {
     }
   };
 }
-var seo028TitleUnique = uniquenessRule({
-  id: "SEO028",
+
+// src/rules/seo/duplicate-title.ts
+var seoDuplicateTitle = uniquenessRule({
+  id: "seo/duplicate-title",
   title: "Duplicate title",
   label: "Unique title",
   noun: "Title",
@@ -2690,8 +3379,10 @@ var seo028TitleUnique = uniquenessRule({
   recommendation: "Give each route a unique <title> that describes that page specifically.",
   rationale: "Duplicate titles across pages make them compete in search results and weaken each page\u2019s relevance signal."
 });
-var seo029DescriptionUnique = uniquenessRule({
-  id: "SEO029",
+
+// src/rules/seo/duplicate-description.ts
+var seoDuplicateDescription = uniquenessRule({
+  id: "seo/duplicate-description",
   title: "Duplicate description",
   label: "Unique description",
   noun: "Description",
@@ -2700,11 +3391,11 @@ var seo029DescriptionUnique = uniquenessRule({
   rationale: "Duplicate meta descriptions give search engines no per-page summary, so they are often ignored or rewritten."
 });
 
-// src/rules/seo/seo030-heading-order.ts
-var docsUrl6 = docsUrlFor("SEO030");
+// src/rules/seo/heading-level-skip.ts
+var docsUrl6 = docsUrlFor("seo/heading-level-skip");
 var recommendation6 = "Increase heading levels one step at a time (do not jump, e.g. from <h2> straight to <h4>).";
-var seo030HeadingOrder = {
-  id: "SEO030",
+var seoHeadingLevelSkip = {
+  id: "seo/heading-level-skip",
   title: "Heading order",
   category: "seo",
   severity: "info",
@@ -2726,7 +3417,7 @@ var seo030HeadingOrder = {
       }
       out.push(
         skip ? {
-          id: "SEO030",
+          id: "seo/heading-level-skip",
           category: "seo",
           severity: "info",
           detection: PENALIZED,
@@ -2737,7 +3428,7 @@ var seo030HeadingOrder = {
           recommendation: recommendation6,
           docsUrl: docsUrl6
         } : {
-          id: "SEO030",
+          id: "seo/heading-level-skip",
           category: "seo",
           severity: "info",
           detection: PASS,
@@ -2752,10 +3443,85 @@ var seo030HeadingOrder = {
   }
 };
 
-// src/rules/component-rule.ts
+// src/rules/kit-module-rule.ts
 var PENALIZED2 = { presence: "none", value: "absent" };
 var PASS2 = { presence: "own", value: "static" };
-function isSuppressed(c, ruleId, line) {
+function isSuppressed(m, ruleId, line) {
+  return (m.suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ruleId)));
+}
+function kitModuleRule(opts) {
+  const docsUrl7 = docsUrlFor(opts.id);
+  const severity = opts.severity ?? "warning";
+  return {
+    id: opts.id,
+    title: opts.title,
+    category: opts.category,
+    severity,
+    scope: "component",
+    rationale: opts.rationale,
+    ...opts.fix ? { fix: opts.fix } : {},
+    async check(ctx) {
+      const out = [];
+      for (const m of ctx.kitModules ?? []) {
+        if (!opts.applies(m, ctx)) continue;
+        const bad = opts.bad(m, ctx).filter((b) => !(b.line > 0 && isSuppressed(m, opts.id, b.line)));
+        if (bad.length === 0) {
+          out.push({
+            id: opts.id,
+            category: opts.category,
+            severity,
+            detection: PASS2,
+            route: m.file,
+            message: opts.label,
+            recommendation: opts.recommendation,
+            docsUrl: docsUrl7
+          });
+          continue;
+        }
+        for (const b of bad) {
+          out.push({
+            id: opts.id,
+            category: opts.category,
+            severity,
+            detection: PENALIZED2,
+            route: m.file,
+            location: m.file,
+            ...b.line > 0 ? { line: b.line } : {},
+            message: b.message,
+            recommendation: opts.recommendation,
+            docsUrl: docsUrl7,
+            ...opts.fix ? { fix: { ...opts.fix } } : {}
+          });
+        }
+      }
+      return out;
+    }
+  };
+}
+
+// src/rules/seo/ssr-disabled.ts
+var ROOT_LAYOUT_RE = /^src\/routes\/\+layout(\.server)?\.(ts|js)$/;
+var PAGE_OPTION_FILE_RE = /\+(page|layout)(\.server)?\.(ts|js)$/;
+var seoSsrDisabled = kitModuleRule({
+  id: "seo/ssr-disabled",
+  title: "SSR disabled",
+  category: "seo",
+  label: "SSR enabled",
+  recommendation: "Keep SSR on for indexable pages; restrict ssr = false to routes that don't need SEO (authenticated dashboards, app-only views). For a deliberate SPA, turn this rule off in the config or add an inline suppression.",
+  rationale: "SvelteKit's SEO guidance is to leave SSR on unless there is a good reason not to: server-rendered content is indexed more frequently and reliably, and SPA mode costs an extra network round trip before anything renders.",
+  applies: (m) => m.ssrDisabled !== void 0 && PAGE_OPTION_FILE_RE.test(m.file),
+  bad: (m) => [
+    {
+      line: m.ssrDisabled.line,
+      message: ROOT_LAYOUT_RE.test(m.file) ? "SSR is disabled for the whole app \u2014 search engines index server-rendered content more reliably, and SPA mode adds a network round trip before first paint" : "SSR is disabled for this route \u2014 its content is invisible to crawlers that don't execute JavaScript and indexes less reliably"
+    }
+  ]
+});
+
+// src/rules/component-rule.ts
+var PENALIZED3 = { presence: "none", value: "absent" };
+var PASS3 = { presence: "own", value: "static" };
+function isSuppressed2(c, ruleId, line) {
   return (c.suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ruleId)));
 }
 function componentRule(opts) {
@@ -2768,17 +3534,18 @@ function componentRule(opts) {
     severity,
     scope: "component",
     rationale: opts.rationale,
+    ...opts.fix ? { fix: opts.fix } : {},
     async check(ctx) {
       const out = [];
       for (const c of ctx.components ?? []) {
         if (!opts.applies(c)) continue;
-        const bad = opts.bad(c).filter((b) => !(b.line > 0 && isSuppressed(c, opts.id, b.line)));
+        const bad = opts.bad(c).filter((b) => !(b.line > 0 && isSuppressed2(c, opts.id, b.line)));
         if (bad.length === 0) {
           out.push({
             id: opts.id,
             category: opts.category,
             severity,
-            detection: PASS2,
+            detection: PASS3,
             route: c.file,
             message: opts.label,
             recommendation: opts.recommendation,
@@ -2791,13 +3558,14 @@ function componentRule(opts) {
             id: opts.id,
             category: opts.category,
             severity,
-            detection: PENALIZED2,
+            detection: PENALIZED3,
             route: c.file,
             location: c.file,
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            docsUrl: docsUrl7,
+            ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
       }
@@ -2806,9 +3574,9 @@ function componentRule(opts) {
   };
 }
 
-// src/rules/correctness/correct001-002.ts
-var correct001EachKey = componentRule({
-  id: "CORRECT001",
+// src/rules/correctness/each-key.ts
+var correctnessEachKey = componentRule({
+  id: "correctness/each-key",
   title: "Keyed each block",
   category: "correctness",
   label: "Keyed {#each}",
@@ -2817,8 +3585,25 @@ var correct001EachKey = componentRule({
   applies: (c) => c.eachBlocks.length > 0,
   bad: (c) => c.eachBlocks.filter((e) => !e.hasKey).map((e) => ({ line: e.line, message: "{#each} block has no key" }))
 });
-var correct002EffectDerived = componentRule({
-  id: "CORRECT002",
+
+// src/rules/correctness/each-index-key.ts
+var correctnessEachIndexKey = componentRule({
+  id: "correctness/each-index-key",
+  title: "Index used as each key",
+  category: "correctness",
+  label: "Item-keyed {#each}",
+  recommendation: "Key by a value that uniquely identifies the item, e.g. (item.id).",
+  rationale: "Svelte's guidance is explicit: the key must uniquely identify the object \u2014 do not use the index. An index key gives items position-based identity, so element state (focus, inputs, transitions) sticks to positions when the list reorders or items are inserted or removed, exactly like an unkeyed block \u2014 but the visible key masks the problem.",
+  applies: (c) => c.eachBlocks.some((e) => e.indexKey),
+  bad: (c) => c.eachBlocks.filter((e) => e.indexKey).map((e) => ({
+    line: e.line,
+    message: "{#each} is keyed by its index \u2014 identity follows position, exactly like an unkeyed block, but the key makes it look safe."
+  }))
+});
+
+// src/rules/correctness/effect-as-derived.ts
+var correctnessEffectAsDerived = componentRule({
+  id: "correctness/effect-as-derived",
   title: "Effect used to derive state",
   category: "correctness",
   label: "$effect usage",
@@ -2827,8 +3612,10 @@ var correct002EffectDerived = componentRule({
   applies: (c) => c.effects.length > 0,
   bad: (c) => c.effects.filter((e) => e.assignsOnlyState).map((e) => ({ line: e.line, message: "$effect only assigns state \u2014 use $derived instead" }))
 });
-var correct003EffectAsOnMount = componentRule({
-  id: "CORRECT003",
+
+// src/rules/correctness/effect-as-onmount.ts
+var correctnessEffectAsOnMount = componentRule({
+  id: "correctness/effect-as-onmount",
   title: "Effect used as onMount",
   category: "correctness",
   label: "$effect usage",
@@ -2838,14 +3625,14 @@ var correct003EffectAsOnMount = componentRule({
   bad: (c) => c.effects.filter((e) => e.mountOnly).map((e) => ({ line: e.line, message: "$effect reads no reactive value \u2014 use onMount instead" }))
 });
 
-// src/rules/correctness/correct004-unmutated-state.ts
-var correct004UnmutatedState = componentRule({
-  id: "CORRECT004",
+// src/rules/correctness/unmutated-state.ts
+var correctnessUnmutatedState = componentRule({
+  id: "correctness/unmutated-state",
   title: "Unmutated $state",
   category: "correctness",
   severity: "info",
   label: "$state usage",
-  recommendation: "If a value never changes, use const; if you only ever reassign it wholesale (never mutate its properties), use $state.raw to skip deep proxying.",
+  recommendation: "If a value never changes, use const \u2014 or $derived if it is computed from props or state; if you only ever reassign it wholesale (never mutate its properties), use $state.raw to skip deep proxying.",
   rationale: "A $state that is never mutated pays for reactivity (deep proxying, tracking) it never uses; const (or $state.raw) is clearer and cheaper.",
   applies: (c) => c.constableStates.length > 0,
   bad: (c) => c.constableStates.map((s) => ({
@@ -2854,24 +3641,62 @@ var correct004UnmutatedState = componentRule({
   }))
 });
 
-// src/rules/correctness/correct005-prop-mutation.ts
-var correct005PropMutation = componentRule({
-  id: "CORRECT005",
+// src/rules/correctness/prop-mutation.ts
+var correctnessPropMutation = componentRule({
+  id: "correctness/prop-mutation",
   title: "Mutated non-bindable prop",
   category: "correctness",
   label: "Prop mutation",
-  recommendation: "Clone the value before mutating it, communicate the change via a callback prop, or declare the prop $bindable if the parent and child should share it.",
-  rationale: "Svelte's docs say plainly: don't mutate props unless they are $bindable. A plain-object prop mutation is a silent no-op (the object isn't a state proxy); a reactive-state-proxy prop mutation works but triggers the ownership_invalid_mutation dev warning only when that code path actually runs. Neither is caught by the compiler, so this rule catches both statically.",
+  recommendation: "Runes mode: clone the value before mutating it, communicate the change via a callback prop, or declare the prop $bindable if the parent and child should share it. Legacy mode: reassign the prop after mutating it (e.g. `list = list`) so Svelte's assignment-based reactivity picks up the change.",
+  rationale: "Svelte's docs say plainly: don't mutate props unless they are $bindable. A plain-object prop mutation is a silent no-op (the object isn't a state proxy); a reactive-state-proxy prop mutation works but triggers the ownership_invalid_mutation dev warning only when that code path actually runs. In legacy mode, mutating methods like .push()/.splice() never trigger an update on their own \u2014 Svelte's reactivity there is based on assignments, not mutations. Neither case is caught by the compiler, so this rule catches both statically.",
   applies: (c) => c.mutatedProps.length > 0,
   bad: (c) => c.mutatedProps.map((m) => ({
     line: m.line,
-    message: `Prop "${m.name}" is mutated, but it is not declared $bindable`
+    message: m.legacy ? `Prop "${m.name}" is mutated directly \u2014 Svelte's legacy-mode reactivity is assignment-based, so this alone will not update the UI. Reassign it after mutating (e.g. "${m.name} = ${m.name}").` : `Prop "${m.name}" is mutated, but it is not declared $bindable`
+  }))
+});
+
+// src/rules/correctness/stale-prop-derivation.ts
+var correctnessStalePropDerivation = componentRule({
+  id: "correctness/stale-prop-derivation",
+  title: "Stale prop derivation",
+  category: "correctness",
+  severity: "warning",
+  label: "Props derived reactively",
+  recommendation: "Wrap the computation in $derived(...) (or $derived.by(() => ...) for a function body) in runes-mode components; prefix the assignment with $: in legacy-mode components.",
+  rationale: "Svelte's guidance is to treat props as though they will change: a plain `let color = type === 'danger' ? 'red' : 'green'` freezes the first render's value, so the UI silently stops tracking the parent when the prop changes. In runes mode, $derived keeps the computation live at no cost; in legacy mode (export let props), a $: reactive statement does the same job.",
+  fix: {
+    description: "Wrap the prop-derived computation in $derived(...) (or $derived.by(() => ...) for a function body) in runes mode, or prefix the assignment with $: in legacy mode, keeping the same expression."
+  },
+  applies: (c) => c.stalePropDerivations.length > 0,
+  bad: (c) => c.stalePropDerivations.map((s) => ({
+    line: s.line,
+    message: s.legacy ? `"${s.name}" is computed from a prop once, at initialization \u2014 it will not update when the prop changes. Prefix the assignment with $: to make it a reactive statement.` : `"${s.name}" is computed from a prop once, at initialization \u2014 it will not update when the prop changes. Wrap it in $derived.`
   }))
 });
 
-// src/rules/correctness/correct006-orphan-effect.ts
-var correct006OrphanEffect = componentRule({
-  id: "CORRECT006",
+// src/rules/correctness/nonreactive-builtin-state.ts
+var correctnessNonreactiveBuiltinState = componentRule({
+  id: "correctness/nonreactive-builtin-state",
+  title: "Non-reactive built-in in $state",
+  category: "correctness",
+  severity: "warning",
+  label: "Reactive collections in $state",
+  recommendation: "Import the reactive equivalent from 'svelte/reactivity' (SvelteMap, SvelteSet, SvelteDate, SvelteURL, SvelteURLSearchParams) and construct that instead.",
+  rationale: "$state deep-proxies plain objects and arrays only; built-in collection, date, and URL instances stay untracked, so property-level changes never reach effects, deriveds, or the template. Svelte's own answer is the drop-in classes in svelte/reactivity.",
+  fix: {
+    description: "Import Svelte<Type> from 'svelte/reactivity' and replace new <Type>(...) with new Svelte<Type>(...) \u2014 the API is identical."
+  },
+  applies: (c) => c.nonreactiveBuiltinStates.length > 0,
+  bad: (c) => c.nonreactiveBuiltinStates.map((s) => ({
+    line: s.line,
+    message: `"${s.name}" is a plain ${s.type} in $state \u2014 its mutations are not tracked, so the UI silently stops updating when it changes. Use Svelte${s.type} from 'svelte/reactivity'.`
+  }))
+});
+
+// src/rules/correctness/orphan-effect.ts
+var correctnessOrphanEffect = componentRule({
+  id: "correctness/orphan-effect",
   title: "Orphan $effect",
   category: "correctness",
   severity: "critical",
@@ -2888,25 +3713,25 @@ var correct006OrphanEffect = componentRule({
   }))
 });
 
-// src/rules/correctness/correct007-orphan-lifecycle.ts
-var PENALIZED3 = { presence: "none", value: "absent" };
-var PASS3 = { presence: "own", value: "static" };
-var ID = "CORRECT007";
+// src/rules/correctness/orphan-lifecycle.ts
+var PENALIZED4 = { presence: "none", value: "absent" };
+var PASS4 = { presence: "own", value: "static" };
+var ID = "correctness/orphan-lifecycle";
 var DOCS_URL = docsUrlFor(ID);
 var LABEL = "Lifecycle-call context";
 var RECOMMENDATION = "Call lifecycle/context functions during component initialisation (the top level of a component's <script>). In load, return the data and call setContext in a layout/page component; in shared modules, expose a setup function that components call during init.";
 var topLevelMessage = (name) => `${name}() runs at module evaluation, outside component initialisation \u2014 it throws lifecycle_outside_component at runtime`;
-function isSuppressed2(suppressions, line) {
+function isSuppressed3(suppressions, line) {
   return (suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ID)));
 }
 function emitFile(out, file, issues, suppressions) {
-  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed2(suppressions, b.line)));
+  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed3(suppressions, b.line)));
   if (bad.length === 0) {
     out.push({
       id: ID,
       category: "correctness",
       severity: "critical",
-      detection: PASS3,
+      detection: PASS4,
       route: file,
       message: LABEL,
       recommendation: RECOMMENDATION,
@@ -2919,7 +3744,7 @@ function emitFile(out, file, issues, suppressions) {
       id: ID,
       category: "correctness",
       severity: "critical",
-      detection: PENALIZED3,
+      detection: PENALIZED4,
       route: file,
       location: file,
       ...b.line > 0 ? { line: b.line } : {},
@@ -2929,7 +3754,7 @@ function emitFile(out, file, issues, suppressions) {
     });
   }
 }
-var correct007OrphanLifecycle = {
+var correctnessOrphanLifecycle = {
   id: ID,
   title: "Lifecycle call outside component initialisation",
   category: "correctness",
@@ -2968,25 +3793,25 @@ var correct007OrphanLifecycle = {
   }
 };
 
-// src/rules/correctness/correct008-browser-globals.ts
-var PENALIZED4 = { presence: "none", value: "absent" };
-var PASS4 = { presence: "own", value: "static" };
-var ID2 = "CORRECT008";
+// src/rules/correctness/server-browser-global.ts
+var PENALIZED5 = { presence: "none", value: "absent" };
+var PASS5 = { presence: "own", value: "static" };
+var ID2 = "correctness/server-browser-global";
 var DOCS_URL2 = docsUrlFor(ID2);
 var LABEL2 = "Server-safe module code";
 var RECOMMENDATION2 = "Move browser-only code into onMount or $effect (they never run on the server), or guard it with browser from $app/environment (or a typeof check).";
 var moduleMessage = (name) => `${name} is accessed at module scope \u2014 it does not exist on the server, so importing this file crashes SSR with "${name} is not defined"`;
-function isSuppressed3(suppressions, line) {
+function isSuppressed4(suppressions, line) {
   return (suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ID2)));
 }
 function emitFile2(out, file, issues, suppressions) {
-  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed3(suppressions, b.line)));
+  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed4(suppressions, b.line)));
   if (bad.length === 0) {
     out.push({
       id: ID2,
       category: "correctness",
       severity: "critical",
-      detection: PASS4,
+      detection: PASS5,
       route: file,
       message: LABEL2,
       recommendation: RECOMMENDATION2,
@@ -2999,7 +3824,7 @@ function emitFile2(out, file, issues, suppressions) {
       id: ID2,
       category: "correctness",
       severity: "critical",
-      detection: PENALIZED4,
+      detection: PENALIZED5,
       route: file,
       location: file,
       ...b.line > 0 ? { line: b.line } : {},
@@ -3009,7 +3834,7 @@ function emitFile2(out, file, issues, suppressions) {
     });
   }
 }
-var correct008BrowserGlobals = {
+var correctnessServerBrowserGlobal = {
   id: ID2,
   title: "Browser global in server module code",
   category: "correctness",
@@ -3045,9 +3870,9 @@ var correct008BrowserGlobals = {
   }
 };
 
-// src/rules/correctness/correct009-instance-browser-globals.ts
-var correct009InstanceBrowserGlobals = componentRule({
-  id: "CORRECT009",
+// src/rules/correctness/instance-browser-global.ts
+var correctnessInstanceBrowserGlobal = componentRule({
+  id: "correctness/instance-browser-global",
   title: "Browser global during component initialisation",
   category: "correctness",
   label: "Server-safe component init",
@@ -3060,9 +3885,9 @@ var correct009InstanceBrowserGlobals = componentRule({
   }))
 });
 
-// src/rules/security/sec001-002.ts
-var sec001Html = componentRule({
-  id: "SEC001",
+// src/rules/security/raw-html.ts
+var securityRawHtml = componentRule({
+  id: "security/raw-html",
   title: "Raw HTML render",
   category: "security",
   label: "{@html} usage",
@@ -3071,8 +3896,10 @@ var sec001Html = componentRule({
   applies: (c) => c.htmlTags.length > 0,
   bad: (c) => c.htmlTags.map((h) => ({ line: h.line, message: "{@html} renders unescaped HTML \u2014 ensure it is sanitized" }))
 });
-var sec002JavascriptUrl = componentRule({
-  id: "SEC002",
+
+// src/rules/security/javascript-url.ts
+var securityJavascriptUrl = componentRule({
+  id: "security/javascript-url",
   title: "javascript: URL",
   category: "security",
   label: "No javascript: URLs",
@@ -3082,63 +3909,9 @@ var sec002JavascriptUrl = componentRule({
   bad: (c) => c.javascriptUrls.map((u) => ({ line: u.line, message: "javascript: URL in an attribute" }))
 });
 
-// src/rules/kit-module-rule.ts
-var PENALIZED5 = { presence: "none", value: "absent" };
-var PASS5 = { presence: "own", value: "static" };
-function isSuppressed4(m, ruleId, line) {
-  return (m.suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ruleId)));
-}
-function kitModuleRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
-  const severity = opts.severity ?? "warning";
-  return {
-    id: opts.id,
-    title: opts.title,
-    category: opts.category,
-    severity,
-    scope: "component",
-    rationale: opts.rationale,
-    async check(ctx) {
-      const out = [];
-      for (const m of ctx.kitModules ?? []) {
-        if (!opts.applies(m, ctx)) continue;
-        const bad = opts.bad(m, ctx).filter((b) => !(b.line > 0 && isSuppressed4(m, opts.id, b.line)));
-        if (bad.length === 0) {
-          out.push({
-            id: opts.id,
-            category: opts.category,
-            severity,
-            detection: PASS5,
-            route: m.file,
-            message: opts.label,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7
-          });
-          continue;
-        }
-        for (const b of bad) {
-          out.push({
-            id: opts.id,
-            category: opts.category,
-            severity,
-            detection: PENALIZED5,
-            route: m.file,
-            location: m.file,
-            ...b.line > 0 ? { line: b.line } : {},
-            message: b.message,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7
-          });
-        }
-      }
-      return out;
-    }
-  };
-}
-
-// src/rules/security/sec003-load-state-write.ts
-var sec003LoadStateWrite = kitModuleRule({
-  id: "SEC003",
+// src/rules/security/handler-state-write.ts
+var securityHandlerStateWrite = kitModuleRule({
+  id: "security/handler-state-write",
   title: "Handler writes imported state",
   category: "security",
   severity: "critical",
@@ -3152,9 +3925,9 @@ var sec003LoadStateWrite = kitModuleRule({
   }))
 });
 
-// src/rules/security/sec004-server-module-state.ts
-var sec004ServerModuleState = kitModuleRule({
-  id: "SEC004",
+// src/rules/security/server-module-state.ts
+var securityServerModuleState = kitModuleRule({
+  id: "security/server-module-state",
   title: "Server module-scope state",
   category: "security",
   label: "Server module state",
@@ -3167,12 +3940,12 @@ var sec004ServerModuleState = kitModuleRule({
   }))
 });
 
-// src/rules/security/sec005-shared-state-import.ts
+// src/rules/security/shared-state-import.ts
 function extSibling(path) {
   return path.endsWith(".svelte.ts") ? path.replace(/\.svelte\.ts$/, ".svelte.js") : path.replace(/\.svelte\.js$/, ".svelte.ts");
 }
-var sec005SharedStateImport = kitModuleRule({
-  id: "SEC005",
+var securitySharedStateImport = kitModuleRule({
+  id: "security/shared-state-import",
   title: "Shared runes-state import on the server",
   category: "security",
   label: "Server state imports",
@@ -3198,11 +3971,10 @@ var sec005SharedStateImport = kitModuleRule({
   }
 });
 
-// src/rules/architecture/arch001-002.ts
+// src/rules/architecture/component-size.ts
 var MAX_LOC = 400;
-var MAX_PROPS = 10;
-var arch001ComponentSize = componentRule({
-  id: "ARCH001",
+var architectureComponentSize = componentRule({
+  id: "architecture/component-size",
   title: "Component size",
   category: "architecture",
   severity: "info",
@@ -3213,8 +3985,11 @@ var arch001ComponentSize = componentRule({
   // skip unanalyzable files (loc 0 = read/parse failure), don't PASS them
   bad: (c) => c.loc > MAX_LOC ? [{ line: 1, message: `Component is ${c.loc} lines (over ${MAX_LOC})` }] : []
 });
-var arch002PropCount = componentRule({
-  id: "ARCH002",
+
+// src/rules/architecture/prop-count.ts
+var MAX_PROPS = 10;
+var architecturePropCount = componentRule({
+  id: "architecture/prop-count",
   title: "Prop count",
   category: "architecture",
   severity: "info",
@@ -3226,13 +4001,13 @@ var arch002PropCount = componentRule({
   bad: (c) => c.propCount > MAX_PROPS ? [{ line: 1, message: `Component takes ${c.propCount} props (over ${MAX_PROPS})` }] : []
 });
 
-// src/rules/perf/perf009-heavy-import.ts
+// src/rules/perf/heavy-import.ts
 var HEAVY_PACKAGES = {
   lodash: "import a submodule (lodash/debounce) or use lodash-es for tree-shaking",
   moment: "use a lighter date library (date-fns or dayjs) \u2014 moment is large and not tree-shakeable"
 };
-var perf009HeavyImport = componentRule({
-  id: "PERF009",
+var performanceHeavyImport = componentRule({
+  id: "performance/heavy-import",
   title: "Heavy dependency import",
   category: "performance",
   severity: "info",
@@ -3256,9 +4031,9 @@ var perf009HeavyImport = componentRule({
   }
 });
 
-// src/rules/perf/perf010-namespace-import.ts
-var perf010NamespaceImport = componentRule({
-  id: "PERF010",
+// src/rules/perf/namespace-import.ts
+var performanceNamespaceImport = componentRule({
+  id: "performance/namespace-import",
   title: "Namespace import",
   category: "performance",
   severity: "info",
@@ -3279,68 +4054,169 @@ var perf010NamespaceImport = componentRule({
   }
 });
 
+// src/rules/perf/minify-disabled.ts
+var PENALIZED6 = { presence: "none", value: "absent" };
+var MINIFY_DISABLED_FIX = {
+  description: "Remove the minify: false override from vite.config (Vite minifies with esbuild by default), or scope it to non-production builds.",
+  snippet: "export default defineConfig({\n  build: {\n    minify: 'esbuild'\n  }\n});",
+  lang: "ts"
+};
+var RECOMMENDATION3 = "Remove build.minify: false from vite.config, or scope it to non-production builds if it is intentional.";
+var performanceMinifyDisabled = {
+  id: "performance/minify-disabled",
+  title: "Minification disabled",
+  category: "performance",
+  severity: "warning",
+  scope: "project",
+  rationale: "Disabling minification ships unminified JS/CSS to production, inflating bundle size several-fold and slowing every page load; the override is usually a leftover from debugging.",
+  fix: MINIFY_DISABLED_FIX,
+  async check(ctx) {
+    const hit = ctx.project.viteMinifyDisabled;
+    if (!hit) return [];
+    const provenance = hit.file === void 0 ? " The override comes from an inline (programmatic) Vite config." : hit.line === void 0 ? " The override was resolved from the actual build \u2014 it may come from a plugin or a conditional config, not a literal in the file." : "";
+    return [
+      {
+        id: "performance/minify-disabled",
+        category: "performance",
+        severity: "warning",
+        detection: PENALIZED6,
+        ...hit.file !== void 0 ? { location: hit.file } : {},
+        ...hit.line !== void 0 ? { line: hit.line } : {},
+        message: "JS/CSS minification is disabled (build.minify: false) \u2014 production bundles ship unminified and several times larger." + provenance,
+        recommendation: RECOMMENDATION3,
+        docsUrl: docsUrlFor("performance/minify-disabled"),
+        fix: { ...MINIFY_DISABLED_FIX }
+      }
+    ];
+  }
+};
+
+// src/rules/perf/load-waterfall.ts
+var MESSAGE = "Sequential dependent awaits in a universal load create a client-side request waterfall \u2014 each hop is a network round trip from the browser. Move this chain to a server load (+page.server.ts / +layout.server.ts), where the hops run server-side.";
+var performanceLoadWaterfall = kitModuleRule({
+  id: "performance/load-waterfall",
+  title: "Load waterfall",
+  category: "performance",
+  severity: "warning",
+  label: "No load waterfalls",
+  recommendation: "Move the dependent await chain into a server load (+page.server.ts / +layout.server.ts), where the hops run server-to-server.",
+  rationale: "In a universal load, every await that depends on a previous result costs a full network round trip from the browser on client-side navigation; chains multiply latency on every page visit. A server load runs the same hops server-side.",
+  fix: {
+    description: "Move the dependent await chain into a server load (+page.server.ts), where hops run server-to-server.",
+    snippet: "// +page.server.ts \u2014 same chain, server-side hops\nexport async function load({ fetch }) {\n  const user = await fetch(`/api/user`).then((r) => r.json());\n  const posts = await fetch(`/api/posts/${user.id}`).then((r) => r.json());\n  return { user, posts };\n}",
+    lang: "ts"
+  },
+  applies: (m) => m.kind === "universal" && m.csrDisabled === void 0 && (m.loadWaterfalls?.dependentLines.length ?? 0) > 0,
+  bad: (m) => m.loadWaterfalls.dependentLines.map((line) => ({ line, message: MESSAGE }))
+});
+
+// src/rules/perf/sequential-awaits.ts
+var MESSAGE2 = "This await does not use the results of the awaits before it \u2014 the requests run sequentially for no reason. Start them together and await them with Promise.all.";
+var performanceSequentialAwaits = kitModuleRule({
+  id: "performance/sequential-awaits",
+  title: "Sequential independent awaits",
+  category: "performance",
+  severity: "info",
+  label: "No needlessly sequential awaits",
+  recommendation: "Start the independent requests together and await them with Promise.all.",
+  rationale: "Awaits that do not use each other's results still run one after another, adding their latencies; starting them together costs nothing and bounds the wait to the slowest request.",
+  fix: {
+    description: "Start the independent requests together and await them with Promise.all.",
+    snippet: "const [a, b] = await Promise.all([fetchA(), fetchB()]);",
+    lang: "ts"
+  },
+  applies: (m) => (m.loadWaterfalls?.independentLines.length ?? 0) > 0,
+  bad: (m) => m.loadWaterfalls.independentLines.map((line) => ({ line, message: MESSAGE2 }))
+});
+
+// src/rules/perf/state-raw.ts
+var performanceStateRaw = componentRule({
+  id: "performance/state-raw",
+  title: "Raw state opportunity",
+  category: "performance",
+  severity: "info",
+  label: "Deep reactivity only where mutated",
+  recommendation: "Declare it with $state.raw(...) \u2014 reassignment stays reactive; only property-level mutation needs the deep proxy.",
+  rationale: "Objects and arrays in $state are made deeply reactive through proxying, which taxes every property access. A binding that is only ever reassigned \u2014 API responses are the canonical case \u2014 never uses that machinery; Svelte's own guidance is to use $state.raw for it.",
+  fix: {
+    description: "Replace $state(...) with $state.raw(...); keep the same initializer."
+  },
+  applies: (c) => c.rawableStates.length > 0,
+  bad: (c) => c.rawableStates.map((s) => ({
+    line: s.line,
+    message: `"${s.name}" is an object/array $state that is only ever reassigned, never mutated \u2014 $state.raw skips the deep-proxy overhead (reassignment stays reactive).`
+  }))
+});
+
 // src/rules/index.ts
 var allRules = [
-  seo001Title,
-  seo002Description,
-  seo003Canonical,
-  seo004OgImage,
-  seo005OgTitle,
-  seo006Robots,
-  seo007Sitemap,
-  seo008JsonLd,
-  seo009HtmlLang,
-  perf001ImageDimensions,
-  perf002ImageLoading,
-  perf003PreloadAs,
-  perf004FontPreloadCrossorigin,
-  seo010Indexability,
-  seo011TwitterCard,
-  seo012OgDescription,
-  seo013OgUrl,
-  seo014Viewport,
-  seo015SitemapInRobots,
-  seo016JsonLdValidity,
-  seo017DeprecatedType,
-  seo018RelativeUrl,
-  seo019DateFormat,
-  seo020Placeholder,
-  seo021RequiredProps,
-  seo022TitleLength,
-  seo023DescriptionLength,
-  seo024Charset,
-  seo025ImageAlt,
-  seo026Hreflang,
-  seo027Heading,
-  perf005LcpImage,
-  perf006ResponsiveImage,
-  perf007RenderBlockingScript,
-  perf008Preconnect,
-  seo028TitleUnique,
-  seo029DescriptionUnique,
-  seo030HeadingOrder,
-  correct001EachKey,
-  correct002EffectDerived,
-  correct003EffectAsOnMount,
-  correct004UnmutatedState,
-  correct005PropMutation,
-  correct006OrphanEffect,
-  correct007OrphanLifecycle,
-  correct008BrowserGlobals,
-  correct009InstanceBrowserGlobals,
-  sec001Html,
-  sec002JavascriptUrl,
-  sec003LoadStateWrite,
-  sec004ServerModuleState,
-  sec005SharedStateImport,
-  arch001ComponentSize,
-  arch002PropCount,
-  perf009HeavyImport,
-  perf010NamespaceImport
+  seoTitlePresence,
+  seoDescriptionPresence,
+  seoCanonicalUrl,
+  seoOgImage,
+  seoOgTitle,
+  seoRobotsTxt,
+  seoSitemapXml,
+  seoJsonLd,
+  seoHtmlLang,
+  performanceImageDimensions,
+  performanceImageLoadingHint,
+  performancePreloadMissingAs,
+  performanceFontPreloadCrossorigin,
+  seoIndexability,
+  seoTwitterCard,
+  seoOgDescription,
+  seoOgUrl,
+  seoViewport,
+  seoSitemapInRobots,
+  seoJsonLdValidity,
+  seoJsonLdDeprecatedType,
+  seoJsonLdRelativeUrl,
+  seoJsonLdDateFormat,
+  seoJsonLdPlaceholder,
+  seoJsonLdRequiredProps,
+  seoTitleLength,
+  seoDescriptionLength,
+  seoCharset,
+  seoImageAlt,
+  seoHreflang,
+  seoSingleH1,
+  performanceLcpImage,
+  performanceResponsiveImage,
+  performanceRenderBlockingScript,
+  performancePreconnect,
+  seoDuplicateTitle,
+  seoDuplicateDescription,
+  seoHeadingLevelSkip,
+  seoSsrDisabled,
+  correctnessEachKey,
+  correctnessEachIndexKey,
+  correctnessEffectAsDerived,
+  correctnessEffectAsOnMount,
+  correctnessUnmutatedState,
+  correctnessPropMutation,
+  correctnessStalePropDerivation,
+  correctnessNonreactiveBuiltinState,
+  correctnessOrphanEffect,
+  correctnessOrphanLifecycle,
+  correctnessServerBrowserGlobal,
+  correctnessInstanceBrowserGlobal,
+  securityRawHtml,
+  securityJavascriptUrl,
+  securityHandlerStateWrite,
+  securityServerModuleState,
+  securitySharedStateImport,
+  architectureComponentSize,
+  architecturePropCount,
+  performanceHeavyImport,
+  performanceNamespaceImport,
+  performanceMinifyDisabled,
+  performanceLoadWaterfall,
+  performanceSequentialAwaits,
+  performanceStateRaw
 ];
 function explainRule(id) {
-  const target = id.toUpperCase();
-  const rule = allRules.find((r) => r.id === target);
+  const rule = allRules.find((r) => r.id === id);
   if (!rule) return void 0;
   return {
     id: rule.id,
@@ -3547,7 +4423,7 @@ function formatConsoleReport(results, config, options = {}) {
   const p = options.palette ?? noColorPalette;
   const summary = summarize(results, config);
   const { health, categories: byCat } = computeHealth(results, config);
-  const present2 = CATEGORY_ORDER.filter((c) => byCat[c] !== void 0);
+  const present3 = CATEGORY_ORDER.filter((c) => byCat[c] !== void 0);
   const lines = [];
   if (!options.omitHeader) {
     lines.push(
@@ -3556,7 +4432,7 @@ function formatConsoleReport(results, config, options = {}) {
       `${p.bold("Health:")} ${scoreColor(p, health)(`${health}/100`)}`
     );
   }
-  for (const c of present2) {
+  for (const c of present3) {
     lines.push(scoreLine(p, CATEGORY_LABEL[c] ?? c, byCat[c]));
   }
   lines.push("");
@@ -4621,8 +5497,8 @@ export {
   allRules,
   applyOverrides,
   applyRuleSeverities,
-  arch001ComponentSize,
-  arch002PropCount,
+  architectureComponentSize,
+  architecturePropCount,
   attrText,
   attrTextOf,
   attrValue,
@@ -4634,15 +5510,18 @@ export {
   collectKitModuleFacts,
   computeHealth,
   computeScore,
-  correct001EachKey,
-  correct002EffectDerived,
-  correct003EffectAsOnMount,
-  correct004UnmutatedState,
-  correct005PropMutation,
-  correct006OrphanEffect,
-  correct007OrphanLifecycle,
-  correct008BrowserGlobals,
-  correct009InstanceBrowserGlobals,
+  correctnessEachIndexKey,
+  correctnessEachKey,
+  correctnessEffectAsDerived,
+  correctnessEffectAsOnMount,
+  correctnessInstanceBrowserGlobal,
+  correctnessNonreactiveBuiltinState,
+  correctnessOrphanEffect,
+  correctnessOrphanLifecycle,
+  correctnessPropMutation,
+  correctnessServerBrowserGlobal,
+  correctnessStalePropDerivation,
+  correctnessUnmutatedState,
   defaultConfig,
   defaultProject,
   defineConfig,
@@ -4653,6 +5532,7 @@ export {
   escapeHtml,
   explainRule,
   findAttr,
+  findMinifyDisabled,
   formatAgentReport,
   formatConsoleReport,
   formatGithubReport,
@@ -4669,16 +5549,20 @@ export {
   noColorPalette,
   parseComponentFacts,
   parseKitModuleFacts,
-  perf001ImageDimensions,
-  perf002ImageLoading,
-  perf003PreloadAs,
-  perf004FontPreloadCrossorigin,
-  perf005LcpImage,
-  perf006ResponsiveImage,
-  perf007RenderBlockingScript,
-  perf008Preconnect,
-  perf009HeavyImport,
-  perf010NamespaceImport,
+  performanceFontPreloadCrossorigin,
+  performanceHeavyImport,
+  performanceImageDimensions,
+  performanceImageLoadingHint,
+  performanceLcpImage,
+  performanceLoadWaterfall,
+  performanceMinifyDisabled,
+  performanceNamespaceImport,
+  performancePreconnect,
+  performancePreloadMissingAs,
+  performanceRenderBlockingScript,
+  performanceResponsiveImage,
+  performanceSequentialAwaits,
+  performanceStateRaw,
   renderAppShell,
   resolveRunesModuleSpecifier,
   runRules,
@@ -4686,42 +5570,43 @@ export {
   scoreBand,
   scoreColor,
   scoresByCategory,
-  sec001Html,
-  sec002JavascriptUrl,
-  sec003LoadStateWrite,
-  sec004ServerModuleState,
-  sec005SharedStateImport,
+  securityHandlerStateWrite,
+  securityJavascriptUrl,
+  securityRawHtml,
+  securityServerModuleState,
+  securitySharedStateImport,
   selectRules,
-  seo001Title,
-  seo002Description,
-  seo003Canonical,
-  seo004OgImage,
-  seo005OgTitle,
-  seo006Robots,
-  seo007Sitemap,
-  seo008JsonLd,
-  seo009HtmlLang,
-  seo010Indexability,
-  seo011TwitterCard,
-  seo012OgDescription,
-  seo013OgUrl,
-  seo014Viewport,
-  seo015SitemapInRobots,
-  seo016JsonLdValidity,
-  seo017DeprecatedType,
-  seo018RelativeUrl,
-  seo019DateFormat,
-  seo020Placeholder,
-  seo021RequiredProps,
-  seo022TitleLength,
-  seo023DescriptionLength,
-  seo024Charset,
-  seo025ImageAlt,
-  seo026Hreflang,
-  seo027Heading,
-  seo028TitleUnique,
-  seo029DescriptionUnique,
-  seo030HeadingOrder,
+  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,
   summarize,
   textFromNodes,
   valueFromNodes