svelte-vitals 0.17.0 → 0.18.0

package/dist/bin.js

@@ -6,7 +6,7 @@ import {
   knownRuleIds,
   readPackageVersion,
   run
-} from "./chunk-VG647TPJ.js";
+} from "./chunk-NLQZ3CMZ.js";
 
 // src/bin.ts
 import mri2 from "mri";
@@ -79,9 +79,13 @@ function resolveArgs(argv) {
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { homedir } from "os";
+import { spawnSync } from "child_process";
 import mri from "mri";
 import * as p from "@clack/prompts";
 
+// src/install/index.ts
+import { join as join3 } from "path";
+
 // src/install/clients.ts
 import { join } from "path";
 var MCP_ENTRY = { command: "npx", args: ["-y", "@svelte-vitals/mcp"] };
@@ -165,12 +169,192 @@ function mergeToml(existing, entry, force) {
   return { content: stringifyToml(root), status };
 }
 
+// src/install/vite-targets.ts
+var VITE_TARGETS = [
+  {
+    id: "vite-plugin",
+    label: "Vite plugin (build gate)",
+    hint: "Fails `vite build` when prerendered pages cross the SEO/Performance threshold"
+  },
+  {
+    id: "vite-dev-overlay",
+    label: "Dev overlay",
+    hint: "Live warnings in `vite dev` only \u2014 never fails a build or CI"
+  }
+];
+function viteTargetById(id) {
+  return VITE_TARGETS.find((t) => t.id === id);
+}
+function isViteTargetId(id) {
+  return VITE_TARGETS.some((t) => t.id === id);
+}
+
+// src/install/codemod-vite-config.ts
+import { parseModule, generateCode, builders, MagicastError } from "magicast";
+var MANUAL_SNIPPET = `import { svelteVitals } from '@svelte-vitals/vite';
+// add svelteVitals() to your \`plugins\` array`;
+function codemodViteConfig(existing) {
+  if (existing === void 0) {
+    return { status: "manual", snippet: MANUAL_SNIPPET };
+  }
+  try {
+    const mod = parseModule(existing);
+    const def = mod.exports.default;
+    const configObj = def?.$type === "function-call" ? def.$args[0] : def;
+    if (!configObj || configObj.$type !== "object" || configObj.plugins?.$type !== "array") {
+      return { status: "manual", snippet: MANUAL_SNIPPET };
+    }
+    const already = configObj.plugins.find(
+      (p2) => p2?.$type === "function-call" && p2?.$callee === "svelteVitals"
+    );
+    if (already !== void 0) {
+      return { status: "exists" };
+    }
+    if (!mod.imports.svelteVitals) {
+      mod.imports.$append({ imported: "svelteVitals", local: "svelteVitals", from: "@svelte-vitals/vite" });
+    }
+    configObj.plugins.unshift(builders.functionCall("svelteVitals"));
+    return { status: "added", content: generateCode(mod, { format: { objectCurlySpacing: true } }).code };
+  } catch (err) {
+    if (err instanceof MagicastError) {
+      return { status: "manual", snippet: MANUAL_SNIPPET };
+    }
+    throw err;
+  }
+}
+
+// src/install/codemod-hooks.ts
+import { parseModule as parseModule2, generateCode as generateCode2, builders as builders2, MagicastError as MagicastError2 } from "magicast";
+var FRESH_HANDLE = `import { svelteVitalsHandle } from '@svelte-vitals/vite/hooks';
+import { sequence } from '@sveltejs/kit/hooks';
+
+export const handle = sequence(svelteVitalsHandle());
+`;
+var MANUAL_SNIPPET2 = `import { svelteVitalsHandle } from '@svelte-vitals/vite/hooks';
+import { sequence } from '@sveltejs/kit/hooks';
+// wrap your existing \`handle\` in sequence(yourHandle, svelteVitalsHandle())`;
+function addImports(mod) {
+  if (!mod.imports.sequence) {
+    mod.imports.$append({ imported: "sequence", local: "sequence", from: "@sveltejs/kit/hooks" });
+  }
+  if (!mod.imports.svelteVitalsHandle) {
+    mod.imports.$append({
+      imported: "svelteVitalsHandle",
+      local: "svelteVitalsHandle",
+      from: "@svelte-vitals/vite/hooks"
+    });
+  }
+}
+function codemodHooksServer(existing) {
+  if (existing === void 0) {
+    return { status: "created", content: FRESH_HANDLE };
+  }
+  try {
+    const mod = parseModule2(existing);
+    const handle = mod.exports.handle;
+    if (handle === void 0) {
+      addImports(mod);
+      mod.exports.handle = builders2.functionCall("sequence", builders2.functionCall("svelteVitalsHandle"));
+      return {
+        status: "added",
+        content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+      };
+    }
+    if (handle.$type === "function-call" && handle.$callee === "sequence") {
+      const already = handle.$args.find(
+        (a) => a?.$type === "function-call" && a?.$callee === "svelteVitalsHandle"
+      );
+      if (already !== void 0) {
+        return { status: "exists" };
+      }
+      if (!mod.imports.svelteVitalsHandle) {
+        mod.imports.$append({
+          imported: "svelteVitalsHandle",
+          local: "svelteVitalsHandle",
+          from: "@svelte-vitals/vite/hooks"
+        });
+      }
+      handle.$args.push(builders2.functionCall("svelteVitalsHandle"));
+      return {
+        status: "added",
+        content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+      };
+    }
+    addImports(mod);
+    mod.exports.handle = builders2.functionCall("sequence", handle, builders2.functionCall("svelteVitalsHandle"));
+    return {
+      status: "updated",
+      content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+    };
+  } catch (err) {
+    if (err instanceof MagicastError2) {
+      return { status: "manual", snippet: MANUAL_SNIPPET2 };
+    }
+    throw err;
+  }
+}
+
+// src/install/package-manager.ts
+import { join as join2 } from "path";
+var LOCKFILE_TO_PM = {
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+function detectPackageManager(io) {
+  for (const [file, pm] of Object.entries(LOCKFILE_TO_PM)) {
+    if (io.readFile(join2(io.cwd, file)) !== void 0) return pm;
+  }
+  return "npm";
+}
+function hasVitePackage(io) {
+  const raw = io.readFile(join2(io.cwd, "package.json"));
+  if (raw === void 0) return false;
+  try {
+    const pkg = JSON.parse(raw);
+    return Boolean(pkg.dependencies?.["@svelte-vitals/vite"] || pkg.devDependencies?.["@svelte-vitals/vite"]);
+  } catch {
+    return false;
+  }
+}
+function installCommand(pm) {
+  const action = pm === "npm" ? "install" : "add";
+  return { command: pm, args: [action, "-D", "@svelte-vitals/vite"] };
+}
+
 // src/install/index.ts
-function planFor(client, scope, io, force) {
+function planForClient(client, scope, io, force) {
   const path = client.resolvePath(scope, io.cwd, io.home);
   const existing = io.readFile(path);
   const merged = client.format === "toml" ? mergeToml(existing, MCP_ENTRY, force) : mergeJson(existing, MCP_ENTRY, force);
-  return { client, scope, path, status: merged.status, content: merged.content };
+  return { id: client.id, label: client.label, scope, path, status: merged.status, content: merged.content };
+}
+function resolveCandidate(io, candidates) {
+  for (const rel of candidates) {
+    const path = join3(io.cwd, rel);
+    const content = io.readFile(path);
+    if (content !== void 0) return { path, content };
+  }
+  return { path: join3(io.cwd, candidates[0]), content: void 0 };
+}
+function planForVitePlugin(io) {
+  const { path, content } = resolveCandidate(io, ["vite.config.ts", "vite.config.js", "vite.config.mjs"]);
+  const result = codemodViteConfig(content);
+  return { id: "vite-plugin", label: viteTargetById("vite-plugin").label, path, ...result };
+}
+function planForDevOverlay(io) {
+  const { path, content } = resolveCandidate(io, ["src/hooks.server.ts", "src/hooks.server.js"]);
+  const result = codemodHooksServer(content);
+  return { id: "vite-dev-overlay", label: viteTargetById("vite-dev-overlay").label, path, ...result };
+}
+function indent(text) {
+  return text.split("\n").map((l) => `      ${l}`).join("\n");
+}
+function rowLine(r) {
+  const head = `  ${r.label}${r.scope ? ` (${r.scope})` : ""} \u2192 ${r.path}  [${r.status}]`;
+  return r.status === "manual" && r.snippet ? `${head}
+${indent(r.snippet)}` : head;
 }
 async function runInstall(flags, io, prompts) {
   let ids;
@@ -184,22 +368,33 @@ async function runInstall(flags, io, prompts) {
         return false;
       }
     };
-    const detected = CLIENTS.filter((c) => c.scopes.some((s) => configExists(c.resolvePath(s, io.cwd, io.home)))).map(
-      (c) => c.id
+    const detectedClients = CLIENTS.filter(
+      (c) => c.scopes.some((s) => configExists(c.resolvePath(s, io.cwd, io.home)))
+    ).map((c) => c.id);
+    const viteConfigExists = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].some(
+      (f) => configExists(join3(io.cwd, f))
     );
-    const picked = await prompts.selectClients(CLIENTS, detected);
+    const detected = [...detectedClients, ...viteConfigExists ? VITE_TARGETS.map((t) => t.id) : []];
+    const options = [
+      ...CLIENTS.map((c) => ({ id: c.id, label: c.label })),
+      ...VITE_TARGETS.map((t) => ({ id: t.id, label: t.label, hint: t.hint }))
+    ];
+    const picked = await prompts.selectClients(options, detected);
     if (picked === null) {
       io.log("Cancelled.");
       return 0;
     }
     ids = picked;
   } else {
-    io.errorLog("svelte-vitals: no TTY; pass --client <claude-code,cursor,codex> to install non-interactively.");
+    io.errorLog(
+      "svelte-vitals: no TTY; pass --client <claude-code,cursor,codex,vite-plugin,vite-dev-overlay> to install non-interactively."
+    );
     return 2;
   }
   const clients = ids.map(clientById).filter((c) => c !== void 0);
-  if (clients.length === 0) {
-    io.errorLog("svelte-vitals: no valid clients selected.");
+  const viteIds = ids.filter(isViteTargetId);
+  if (clients.length === 0 && viteIds.length === 0) {
+    io.errorLog("svelte-vitals: no valid clients or targets selected.");
     return 2;
   }
   const rows = [];
@@ -220,7 +415,7 @@ async function runInstall(flags, io, prompts) {
       scope = "project";
     }
     try {
-      rows.push(planFor(client, scope, io, flags.force ?? false));
+      rows.push(planForClient(client, scope, io, flags.force ?? false));
     } catch (err) {
       const path = client.resolvePath(scope, io.cwd, io.home);
       io.errorLog(
@@ -229,7 +424,10 @@ async function runInstall(flags, io, prompts) {
       return 2;
     }
   }
-  const planText = rows.map((r) => `  ${r.client.label} (${r.scope}) \u2192 ${r.path}  [${r.status}]`).join("\n");
+  for (const viteId of viteIds) {
+    rows.push(viteId === "vite-plugin" ? planForVitePlugin(io) : planForDevOverlay(io));
+  }
+  const planText = rows.map(rowLine).join("\n");
   io.log("Plan:");
   io.log(planText);
   if (flags.dryRun) {
@@ -244,41 +442,63 @@ async function runInstall(flags, io, prompts) {
     }
   }
   let hadFailure = false;
+  let viteWasWritten = false;
   for (const r of rows) {
     if (r.status === "exists") {
-      io.log(`= ${r.client.label}: already configured (${r.path}) \u2014 use --force to overwrite.`);
+      const hint = isViteTargetId(r.id) ? "" : " \u2014 use --force to overwrite";
+      io.log(`= ${r.label}: already configured (${r.path})${hint}.`);
+      continue;
+    }
+    if (r.status === "manual") {
+      io.log(`! ${r.label}: couldn't safely modify ${r.path} \u2014 add this by hand:
+${indent(r.snippet ?? "")}`);
       continue;
     }
     try {
-      io.writeFile(r.path, r.content);
-      io.log(`\u2713 ${r.client.label}: ${r.status} ${r.path}`);
+      io.writeFile(r.path, r.content ?? "");
+      io.log(`\u2713 ${r.label}: ${r.status} ${r.path}`);
+      if (isViteTargetId(r.id)) viteWasWritten = true;
     } catch (err) {
       hadFailure = true;
       io.errorLog(`svelte-vitals: failed to write ${r.path}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  if (viteWasWritten && io.runCommand && !hasVitePackage(io)) {
+    const pm = detectPackageManager(io);
+    const { command, args } = installCommand(pm);
+    io.log(`Installing @svelte-vitals/vite via ${pm}...`);
+    const code = io.runCommand(command, args, io.cwd);
+    if (code !== 0) {
+      io.errorLog(
+        `svelte-vitals: failed to install @svelte-vitals/vite (${command} ${args.join(" ")} exited ${code}). Install it manually.`
+      );
+    }
+  }
   if (hadFailure) return 2;
   io.log("");
-  io.log("Done. Restart your client to load the svelte-vitals MCP server.");
+  if (clients.length > 0) io.log("Restart your client to load the svelte-vitals MCP server.");
+  if (viteWasWritten) io.log("Restart `vite dev` (or your build) to pick up the change.");
+  io.log("Done.");
   return 0;
 }
 
 // src/install/args.ts
-var VALID_CLIENTS = CLIENTS.map((c) => c.id);
+var VALID_TARGETS = [...CLIENTS.map((c) => c.id), ...VITE_TARGETS.map((t) => t.id)];
+var EXPECTED_TARGETS = VALID_TARGETS.join("|");
 function resolveInstallArgs(argv) {
   const warnings = [];
   const errors = [];
   const rawClients = typeof argv.client === "string" ? argv.client.split(",").map((s) => s.trim()).filter(Boolean) : [];
   const client = [];
   for (const c of rawClients) {
-    if (VALID_CLIENTS.includes(c)) {
+    if (VALID_TARGETS.includes(c)) {
       if (!client.includes(c)) client.push(c);
     } else {
-      warnings.push(`svelte-vitals: unknown --client '${c}'; expected claude-code|cursor|codex. Skipping.`);
+      warnings.push(`svelte-vitals: unknown --client '${c}'; expected ${EXPECTED_TARGETS}. Skipping.`);
     }
   }
   if (rawClients.length > 0 && client.length === 0) {
-    errors.push("svelte-vitals: no valid --client values; expected claude-code|cursor|codex.");
+    errors.push(`svelte-vitals: no valid --client values; expected ${EXPECTED_TARGETS}.`);
   }
   let scope;
   const rawScope = argv.scope;
@@ -307,7 +527,10 @@ Usage:
   svelte-vitals install [options]
 
 Options:
-  --client <ids>    Comma-separated: claude-code,cursor,codex (skips the interactive picker)
+  --client <ids>    Comma-separated: claude-code,cursor,codex,vite-plugin,vite-dev-overlay (skips the interactive picker)
+                    vite-plugin registers the build-mode plugin in vite.config.{ts,js,mjs}; vite-dev-overlay
+                    wires up the dev-overlay hook in src/hooks.server.{ts,js}. --force does not apply
+                    to either \u2014 an existing registration is always left as-is.
   --scope <scope>   project | global (applies to all selected clients; codex is always global)
   --yes, -y         Skip the confirmation prompt
   --dry-run         Print the planned changes and exit without writing
@@ -331,15 +554,32 @@ function realIO() {
     home: homedir(),
     isTTY: Boolean(process.stdout.isTTY),
     log: (line) => console.log(line),
-    errorLog: (line) => console.error(line)
+    errorLog: (line) => console.error(line),
+    runCommand: (command, args, cwd) => {
+      const result = spawnSync(command, args, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        timeout: 12e4
+      });
+      if (result.error) {
+        console.error(`svelte-vitals: ${command} failed to start: ${result.error.message}`);
+        return 1;
+      }
+      if (result.signal) {
+        console.error(`svelte-vitals: ${command} was terminated (${result.signal}) \u2014 it may have timed out.`);
+        return 1;
+      }
+      return result.status ?? 1;
+    }
   };
 }
 function clackPrompts() {
   return {
     selectClients: async (all, defaults) => {
       const res = await p.multiselect({
-        message: "Which clients should svelte-vitals be installed for?",
-        options: all.map((c) => ({ value: c.id, label: c.label })),
+        message: "Which clients/targets should svelte-vitals be installed for?",
+        options: all.map((o) => ({ value: o.id, label: o.label, hint: o.hint })),
         initialValues: defaults,
         required: true
       });

package/dist/{chunk-VG647TPJ.js → chunk-NLQZ3CMZ.js}

@@ -124,6 +124,15 @@ async function collectProjectFacts(rt, cwd) {
 
 // src/providers/source/parse.ts
 import { parse } from "svelte/compiler";
+import {
+  CHILD_NODE_KEYS,
+  lineOf,
+  findAttr,
+  valueFromNodes,
+  textFromNodes,
+  attrText,
+  attrValue
+} from "@svelte-vitals/core";
 
 // src/providers/source/imports.ts
 function addImportsFromProgram(program, map) {
@@ -150,58 +159,6 @@ function collectImports(ast) {
 }
 
 // src/providers/source/parse.ts
-var CHILD_NODE_KEYS = [
-  "fragment",
-  "nodes",
-  "consequent",
-  "alternate",
-  "body",
-  "pending",
-  "then",
-  "catch",
-  "fallback"
-];
-function valueFromNodes(nodes) {
-  if (!Array.isArray(nodes)) return "absent";
-  if (nodes.some((n) => n?.type === "ExpressionTag")) return "dynamic";
-  const text = nodes.filter((n) => n?.type === "Text").map((n) => String(n.data ?? "")).join("");
-  return text.trim().length > 0 ? "static" : "absent";
-}
-function textFromNodes(nodes) {
-  if (!Array.isArray(nodes) || nodes.some((n) => n?.type === "ExpressionTag")) return void 0;
-  const text = nodes.filter((n) => n?.type === "Text").map((n) => String(n.data ?? "")).join("");
-  return text.trim().length > 0 ? text : void 0;
-}
-function attrText(attributes, name) {
-  const attr = findAttr(attributes, name);
-  if (!attr) return void 0;
-  const v = attr.value;
-  if (v === true) return "";
-  if (Array.isArray(v)) {
-    return v.filter((n) => n?.type === "Text").map((n) => String(n.data ?? "")).join("");
-  }
-  return void 0;
-}
-function attrValue(attributes, name) {
-  const attr = findAttr(attributes, name);
-  if (!attr) return "absent";
-  const v = attr.value;
-  if (v === true) return "absent";
-  if (Array.isArray(v)) return valueFromNodes(v);
-  if (v && v.type === "ExpressionTag") return "dynamic";
-  return "absent";
-}
-function lineOf(source, offset) {
-  if (typeof offset !== "number" || offset < 0) return 0;
-  let line = 1;
-  const end = Math.min(offset, source.length);
-  for (let i = 0; i < end; i++) if (source[i] === "\n") line++;
-  return line;
-}
-function findAttr(attributes, name) {
-  if (!Array.isArray(attributes)) return void 0;
-  return attributes.find((a) => a?.type === "Attribute" && a.name === name);
-}
 function collectSvelteHeads(node, acc) {
   if (Array.isArray(node)) {
     for (const child of node) collectSvelteHeads(child, acc);
@@ -279,19 +236,6 @@ function tagsFromHead(head) {
   }
   return tags;
 }
-function attrValueOf(attr) {
-  const v = attr?.value;
-  if (v === true) return "absent";
-  if (Array.isArray(v)) return valueFromNodes(v);
-  if (v && v.type === "ExpressionTag") return "dynamic";
-  return "absent";
-}
-function attrTextOf(attr) {
-  const v = attr?.value;
-  if (!Array.isArray(v) || v.some((n) => n?.type === "ExpressionTag")) return void 0;
-  const text = v.filter((n) => n?.type === "Text").map((n) => String(n.data ?? "")).join("");
-  return text.trim().length > 0 ? text : void 0;
-}
 function collectComponents(node, acc) {
   if (Array.isArray(node)) {
     for (const child of node) collectComponents(child, acc);
@@ -366,312 +310,9 @@ function parseFile(source, filename) {
     headings
   };
 }
-function isConstantListEach(node) {
-  const expr = node?.expression;
-  return expr?.type === "ArrayExpression" && Array.isArray(expr.elements) && !expr.elements.some((el) => el?.type === "SpreadElement");
-}
-function collectEachBlocks(node, source, acc) {
-  if (Array.isArray(node)) {
-    for (const child of node) collectEachBlocks(child, source, acc);
-    return;
-  }
-  if (!node || typeof node !== "object") return;
-  if (node.type === "EachBlock" && !isConstantListEach(node)) {
-    acc.push({ hasKey: node.key != null, line: lineOf(source, node.start) });
-  }
-  for (const key of CHILD_NODE_KEYS) {
-    if (key in node) collectEachBlocks(node[key], source, acc);
-  }
-}
-function walkEstree(node, visit) {
-  if (Array.isArray(node)) {
-    for (const child of node) walkEstree(child, visit);
-    return;
-  }
-  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
-    walkEstree(node[key], visit);
-  }
-}
-function isEffectCall(node) {
-  const c = node?.callee;
-  if (c?.type === "Identifier") return c.name === "$effect";
-  if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$effect") {
-    return c.property?.type === "Identifier" && c.property.name === "pre";
-  }
-  return false;
-}
-function isStateDeclaration(node) {
-  const c = node?.callee;
-  if (c?.type === "Identifier") return c.name === "$state";
-  if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$state") {
-    return c.property?.type === "Identifier" && (c.property.name === "raw" || c.property.name === "frozen");
-  }
-  return false;
-}
-function bodyOnlyAssignsState(fn, stateNames) {
-  const isStateAssign = (expr) => expr?.type === "AssignmentExpression" && expr.operator === "=" && expr.left?.type === "Identifier" && stateNames.has(expr.left.name);
-  const body = fn?.body;
-  if (!body) return false;
-  if (body.type !== "BlockStatement") return isStateAssign(body);
-  if (body.body.length === 0) return false;
-  return body.body.every((s) => s?.type === "ExpressionStatement" && isStateAssign(s.expression));
-}
-function isDerivedDeclaration(node) {
-  const c = node?.callee;
-  if (c?.type === "Identifier") return c.name === "$derived";
-  if (c?.type === "MemberExpression" && c.object?.type === "Identifier" && c.object.name === "$derived") {
-    return c.property?.type === "Identifier" && c.property.name === "by";
-  }
-  return false;
-}
-function addBoundNames(id, acc) {
-  if (!id) return;
-  switch (id.type) {
-    case "Identifier":
-      acc.add(id.name);
-      break;
-    case "ObjectPattern":
-      for (const p of id.properties ?? []) {
-        if (p?.type === "Property") addBoundNames(p.value, acc);
-        else if (p?.type === "RestElement") addBoundNames(p.argument, acc);
-      }
-      break;
-    case "ArrayPattern":
-      for (const el of id.elements ?? []) addBoundNames(el, acc);
-      break;
-    case "AssignmentPattern":
-      addBoundNames(id.left, acc);
-      break;
-    case "RestElement":
-      addBoundNames(id.argument, acc);
-      break;
-  }
-}
-function rootObjectName(node) {
-  let cur = node;
-  while (cur?.type === "MemberExpression") cur = cur.object;
-  return cur?.type === "Identifier" ? cur.name : void 0;
-}
-function collectStateWrites(root, stateNames, acc) {
-  walkEstree(root, (n) => {
-    if (n?.type === "AssignmentExpression") {
-      if (n.left?.type === "Identifier" && stateNames.has(n.left.name)) acc.add(n.left.name);
-      else if (n.left?.type === "MemberExpression") {
-        const r = rootObjectName(n.left);
-        if (r && stateNames.has(r)) acc.add(r);
-      } 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)) acc.add(name);
-      }
-    } else if (n?.type === "UpdateExpression") {
-      const r = rootObjectName(n.argument);
-      if (r && stateNames.has(r)) acc.add(r);
-    } else if (n?.type === "UnaryExpression" && n.operator === "delete") {
-      const r = rootObjectName(n.argument);
-      if (r && stateNames.has(r)) acc.add(r);
-    } else if (n?.type === "CallExpression") {
-      if (n.callee?.type === "MemberExpression") {
-        const r = rootObjectName(n.callee);
-        if (r && stateNames.has(r)) acc.add(r);
-      }
-      for (const a of n.arguments ?? []) {
-        const arg = a?.type === "SpreadElement" ? a.argument : a;
-        const r = rootObjectName(arg);
-        if (r && stateNames.has(r)) acc.add(r);
-      }
-    }
-  });
-}
-var COMPONENT_LIKE_TYPES = /* @__PURE__ */ new Set(["Component", "SvelteComponent", "SvelteSelf"]);
-function collectTemplateEscapes(node, stateNames, acc) {
-  if (Array.isArray(node)) {
-    for (const c of node) collectTemplateEscapes(c, stateNames, acc);
-    return;
-  }
-  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
-  if (Array.isArray(node.attributes)) {
-    for (const attr of node.attributes) {
-      if (attr?.type === "BindDirective") {
-        const r = rootObjectName(attr.expression);
-        if (r && stateNames.has(r)) acc.add(r);
-      } else if (COMPONENT_LIKE_TYPES.has(node.type)) {
-        walkEstree(attr, (m) => {
-          if (m?.type === "Identifier" && stateNames.has(m.name)) acc.add(m.name);
-        });
-      }
-    }
-  }
-  for (const key of CHILD_NODE_KEYS) {
-    if (key in node) collectTemplateEscapes(node[key], stateNames, acc);
-  }
-}
-var RUNE_NAMES = /* @__PURE__ */ new Set(["$state", "$derived", "$effect", "$props", "$bindable", "$inspect", "$host"]);
-function bodyReadsReactive(fn, reactiveNames) {
-  let reads = false;
-  const IGNORED_KEYS = /* @__PURE__ */ new Set(["type", "start", "end", "loc", "range"]);
-  const visit = (n) => {
-    if (reads || !n) return;
-    if (Array.isArray(n)) {
-      for (const c of n) visit(c);
-      return;
-    }
-    if (typeof n !== "object" || typeof n.type !== "string") return;
-    if (n.type === "Identifier") {
-      if (reactiveNames.has(n.name) || n.name.startsWith("$") && !RUNE_NAMES.has(n.name)) reads = true;
-      return;
-    }
-    if (n.type === "CallExpression" && n.callee?.type === "Identifier") {
-      reads = true;
-      return;
-    }
-    if (n.type === "MemberExpression") {
-      visit(n.object);
-      if (n.computed) visit(n.property);
-      return;
-    }
-    if (n.type === "Property") {
-      if (n.computed) visit(n.key);
-      visit(n.value);
-      return;
-    }
-    for (const key of Object.keys(n)) {
-      if (!IGNORED_KEYS.has(key)) visit(n[key]);
-    }
-  };
-  visit(fn.body);
-  return reads;
-}
-function bodyIsEmpty(fn) {
-  const body = fn?.body;
-  if (!body) return true;
-  if (body.type === "BlockStatement") return (body.body ?? []).length === 0;
-  return false;
-}
-var URL_ATTRS = ["href", "src", "action", "formaction"];
-function collectSecurityFacts(node, source, htmlTags, jsUrls) {
-  if (Array.isArray(node)) {
-    for (const child of node) collectSecurityFacts(child, source, htmlTags, jsUrls);
-    return;
-  }
-  if (!node || typeof node !== "object") return;
-  if (node.type === "HtmlTag") htmlTags.push({ line: lineOf(source, node.start) });
-  if ((node.type === "RegularElement" || node.type === "SvelteElement") && Array.isArray(node.attributes)) {
-    for (const name of URL_ATTRS) {
-      const attr = findAttr(node.attributes, name);
-      if (!attr) continue;
-      const value = attrTextOf(attr);
-      if (value !== void 0 && /^\s*javascript:/i.test(value)) {
-        jsUrls.push({ line: lineOf(source, attr.start ?? node.start) });
-      }
-    }
-  }
-  for (const key of CHILD_NODE_KEYS) {
-    if (key in node) collectSecurityFacts(node[key], source, htmlTags, jsUrls);
-  }
-}
-function isPropsCall(node) {
-  return node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "$props";
-}
-function countProps(program) {
-  let count = 0;
-  let seen = 0;
-  let uncountable = false;
-  walkEstree(program, (n) => {
-    if (n.type !== "VariableDeclarator" || !n.init || !isPropsCall(n.init)) return;
-    seen++;
-    const props = n.id?.type === "ObjectPattern" ? n.id.properties : void 0;
-    if (!Array.isArray(props) || props.some((p) => p?.type === "RestElement")) {
-      uncountable = true;
-      return;
-    }
-    count = props.filter((p) => p?.type === "Property").length;
-  });
-  return uncountable || seen > 1 ? 0 : count;
-}
-function countLines(source) {
-  if (source.length === 0) return 0;
-  return source.split("\n").length - (source.endsWith("\n") ? 1 : 0);
-}
-function collectImportSources(program, acc) {
-  walkEstree(program, (n) => {
-    if (n.type === "ImportDeclaration" && typeof n.source?.value === "string") acc.push(n.source.value);
-  });
-}
-function isBareSpecifier(s) {
-  return !/^[./$#]/.test(s);
-}
-function collectNamespaceImports(program, source, acc) {
-  walkEstree(program, (n) => {
-    if (n.type !== "ImportDeclaration" || n.importKind === "type") return;
-    const spec = n.source?.value;
-    if (typeof spec !== "string" || !isBareSpecifier(spec)) return;
-    if (Array.isArray(n.specifiers) && n.specifiers.some((s) => s?.type === "ImportNamespaceSpecifier")) {
-      acc.push({ source: spec, line: lineOf(source, n.start) });
-    }
-  });
-}
-function parseComponentFacts(source, filename) {
-  const ast = parse(source, { modern: true, filename });
-  const eachBlocks = [];
-  collectEachBlocks(ast.fragment ?? ast, source, eachBlocks);
-  const htmlTags = [];
-  const javascriptUrls = [];
-  collectSecurityFacts(ast.fragment ?? ast, source, htmlTags, javascriptUrls);
-  const loc = countLines(source);
-  const imports = [];
-  const namespaceImports = [];
-  if (ast.module?.content) {
-    collectImportSources(ast.module.content, imports);
-    collectNamespaceImports(ast.module.content, source, namespaceImports);
-  }
-  const effects = [];
-  const constableStates = [];
-  let propCount = 0;
-  const program = ast.instance?.content;
-  if (program) {
-    collectImportSources(program, imports);
-    collectNamespaceImports(program, source, namespaceImports);
-    propCount = countProps(program);
-    const stateNames = /* @__PURE__ */ new Set();
-    const reactiveNames = /* @__PURE__ */ new Set();
-    const stateDecls = [];
-    walkEstree(program, (n) => {
-      if (n.type !== "VariableDeclarator" || !n.init) return;
-      if (isStateDeclaration(n.init) && n.id?.type === "Identifier") {
-        stateNames.add(n.id.name);
-        stateDecls.push({ name: n.id.name, line: lineOf(source, n.start) });
-      }
-      if (isStateDeclaration(n.init) || isDerivedDeclaration(n.init) || isPropsCall(n.init))
-        addBoundNames(n.id, reactiveNames);
-    });
-    walkEstree(program, (n) => {
-      if (n.type !== "CallExpression" || !isEffectCall(n)) return;
-      const fn = n.arguments?.[0];
-      const isFn = fn?.type === "ArrowFunctionExpression" || fn?.type === "FunctionExpression";
-      effects.push({
-        line: lineOf(source, n.start),
-        assignsOnlyState: isFn ? bodyOnlyAssignsState(fn, stateNames) : false,
-        mountOnly: isFn ? !bodyIsEmpty(fn) && !bodyReadsReactive(fn, reactiveNames) : false
-      });
-    });
-    const writtenOrEscaped = /* @__PURE__ */ new Set();
-    collectStateWrites(program, stateNames, writtenOrEscaped);
-    if (ast.fragment) {
-      collectStateWrites(ast.fragment, stateNames, writtenOrEscaped);
-      collectTemplateEscapes(ast.fragment, stateNames, writtenOrEscaped);
-    }
-    for (const d of stateDecls) {
-      if (!writtenOrEscaped.has(d.name)) constableStates.push(d);
-    }
-  }
-  return { eachBlocks, effects, htmlTags, javascriptUrls, loc, propCount, imports, namespaceImports, constableStates };
-}
 
 // src/providers/source/adapters/svelte-meta-tags.ts
+import { attrValueOf, attrTextOf } from "@svelte-vitals/core";
 function findAttr2(attributes, name) {
   return attributes.find((a) => a?.type === "Attribute" && a.name === name);
 }
@@ -709,6 +350,7 @@ var svelteMetaTagsAdapter = {
 };
 
 // src/providers/source/adapters/svelte-seo.ts
+import { attrValueOf as attrValueOf2, attrTextOf as attrTextOf2 } from "@svelte-vitals/core";
 function findAttr3(attributes, name) {
   return attributes.find((a) => a?.type === "Attribute" && a.name === name);
 }
@@ -721,18 +363,18 @@ var svelteSeoAdapter = {
     const attrs = use.attributes;
     const title = findAttr3(attrs, "title");
     if (title) {
-      const value = attrValueOf(title);
-      const text = value === "static" ? attrTextOf(title) : void 0;
+      const value = attrValueOf2(title);
+      const text = value === "static" ? attrTextOf2(title) : void 0;
       tags.push({ kind: "title", value, ...text !== void 0 ? { text } : {} });
     }
     const description = findAttr3(attrs, "description");
     if (description) {
-      const value = attrValueOf(description);
-      const text = value === "static" ? attrTextOf(description) : void 0;
+      const value = attrValueOf2(description);
+      const text = value === "static" ? attrTextOf2(description) : void 0;
       tags.push({ kind: "meta", name: "description", value, ...text !== void 0 ? { text } : {} });
     }
     const canonical = findAttr3(attrs, "canonical");
-    if (canonical) tags.push({ kind: "link", rel: "canonical", value: attrValueOf(canonical) });
+    if (canonical) tags.push({ kind: "link", rel: "canonical", value: attrValueOf2(canonical) });
     const openGraph = findAttr3(attrs, "openGraph");
     const broad = use.hasSpread || Boolean(openGraph);
     return { tags, broad };
@@ -936,6 +578,7 @@ async function collectRoutes(rt, cwd, config = defaultConfig) {
 }
 
 // src/providers/source/components.ts
+import { parseComponentFacts } from "@svelte-vitals/core";
 async function collectComponentFacts(rt, cwd) {
   const files = await rt.glob("src/**/*.svelte", cwd);
   return Promise.all(
@@ -954,7 +597,8 @@ async function collectComponentFacts(rt, cwd) {
           propCount: 0,
           imports: [],
           namespaceImports: [],
-          constableStates: []
+          constableStates: [],
+          suppressions: []
         };
       }
     })

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   routeMatcher,
   run,
   spinnerEnabled
-} from "./chunk-VG647TPJ.js";
+} from "./chunk-NLQZ3CMZ.js";
 export {
   ProjectError,
   analyzeProject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-vitals",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "A SvelteKit SEO checker — not a runtime Web Vitals reporter. Static analysis of your routes' head metadata.",
   "type": "module",
   "license": "MIT",
@@ -39,15 +39,16 @@
     "dist"
   ],
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
+    "@clack/prompts": "^1.6.0",
+    "magicast": "^0.5.3",
     "mri": "^1.2.0",
     "smol-toml": "^1.7.0",
-    "svelte": "^5.56.3",
+    "svelte": "^5.56.4",
     "tinyglobby": "^0.2.17",
-    "@svelte-vitals/core": "0.18.0"
+    "@svelte-vitals/core": "0.19.0"
   },
   "devDependencies": {
-    "@types/node": "^24.7.0"
+    "@types/node": "^24.13.2"
   },
   "scripts": {
     "build": "tsup",