crawlemon 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import os from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 import { spawnSync } from "node:child_process";
 
 // ../next-adapter/src/parser.ts
@@ -197,20 +197,646 @@ function parsePageSource(content, framework = "nextjs") {
 }
 
 // ../next-adapter/src/scanner.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 
 // ../next-adapter/src/dependency-graph.ts
 import fs from "node:fs";
 import path from "node:path";
+
+// ../next-adapter/src/value-parser.ts
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\xA0";
+}
+function skipTrivia(text, index) {
+  let i = index;
+  while (i < text.length) {
+    if (isWhitespace(text[i])) {
+      i += 1;
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i += 1;
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? text.length : end + 2;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function readStringLiteral(text, index) {
+  const quote = text[index];
+  let i = index + 1;
+  let value = "";
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      value += text[i + 1] ?? "";
+      i += 2;
+      continue;
+    }
+    if (ch === quote) return { value, end: i + 1 };
+    value += ch;
+    i += 1;
+  }
+  return { value, end: i };
+}
+function readTemplateLiteral(text, index) {
+  let i = index + 1;
+  let depth = 0;
+  let value = "";
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      value += text[i + 1] ?? "";
+      i += 2;
+      continue;
+    }
+    if (ch === "`" && depth === 0) return { value, end: i + 1 };
+    if (ch === "$" && text[i + 1] === "{") {
+      depth += 1;
+      value += "${";
+      i += 2;
+      continue;
+    }
+    if (depth > 0 && ch === "}") {
+      depth -= 1;
+      value += "}";
+      i += 1;
+      continue;
+    }
+    value += ch;
+    i += 1;
+  }
+  return { value, end: i };
+}
+function readIdentifier(text, index) {
+  let i = index;
+  while (i < text.length && /[A-Za-z0-9_$]/.test(text[i])) i += 1;
+  return { name: text.slice(index, i), end: i };
+}
+function readTemplateWhole(text, index) {
+  return readTemplateLiteral(text, index);
+}
+function readBalanced(text, open) {
+  const closer = { "(": ")", "[": "]", "{": "}" };
+  const expected = closer[text[open]];
+  if (!expected) return open + 1;
+  let depth = 0;
+  let i = open;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'") {
+      i = readStringLiteral(text, i).end;
+      continue;
+    }
+    if (ch === "`") {
+      i = readTemplateWhole(text, i).end;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      i = skipTrivia(text, i);
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      i = skipTrivia(text, i);
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") depth += 1;
+    else if (ch === "}" || ch === "]" || ch === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+    i += 1;
+  }
+  return text.length;
+}
+function stripTsSuffix(raw) {
+  let text = raw.trim();
+  text = text.replace(/^as\s+const\s*/i, "");
+  text = text.replace(/\s+as\s+const\s*$/i, "").replace(/\s+satisfies\s+[A-Za-z_][\w.\[\]'"<>|&]*\s*$/i, "");
+  return text.trim();
+}
+function parseTemplateValue(text, index) {
+  const { value, end } = readTemplateWhole(text, index);
+  const parts = [];
+  let cursor = 0;
+  while (cursor < value.length) {
+    const dollar = value.indexOf("${", cursor);
+    if (dollar === -1) {
+      if (cursor < value.length) parts.push({ t: "str", value: value.slice(cursor) });
+      break;
+    }
+    if (dollar > cursor) parts.push({ t: "str", value: value.slice(cursor, dollar) });
+    const exprEnd = findClosingBrace(value, dollar + 1);
+    const exprRaw = value.slice(dollar + 2, exprEnd);
+    let parsed = { t: "unresolved", raw: exprRaw };
+    try {
+      const parsedExpr = parseValue(exprRaw);
+      if (parsedExpr.t !== "unresolved") parsed = parsedExpr;
+    } catch {
+      parsed = { t: "unresolved", raw: exprRaw };
+    }
+    parts.push(parsed);
+    cursor = exprEnd + 1;
+  }
+  return { node: { t: "template", parts, raw: value }, end };
+}
+function findClosingBrace(text, atOpen) {
+  let depth = 0;
+  let i = atOpen;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "'" || ch === '"') {
+      i = readStringLiteral(text, i).end;
+      continue;
+    }
+    if (ch === "`") {
+      i = readTemplateWhole(text, i).end;
+      continue;
+    }
+    if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+    i += 1;
+  }
+  return text.length;
+}
+function scanContainerElementEnd(text, index) {
+  let depth = 0;
+  let i = index;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'") {
+      i = readStringLiteral(text, i).end;
+      continue;
+    }
+    if (ch === "`") {
+      i = readTemplateWhole(text, i).end;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? text.length : end + 2;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]" || ch === ")") {
+      if (depth === 0) return i;
+      depth -= 1;
+    } else if (depth === 0 && ch === ",") {
+      return i;
+    }
+    i += 1;
+  }
+  return text.length;
+}
+function parseObjectValue(text, index) {
+  const props = [];
+  let i = skipTrivia(text, index + 1);
+  if (text[i] === "}") return { node: { t: "obj", props }, end: i + 1 };
+  while (i < text.length) {
+    i = skipTrivia(text, i);
+    const ch = text[i];
+    if (ch === "}") return { node: { t: "obj", props }, end: i + 1 };
+    if (ch === ",") {
+      i += 1;
+      continue;
+    }
+    if (ch === ".") {
+      const restEnd = scanContainerElementEnd(text, i);
+      if (restEnd === text.length) return { node: { t: "obj", props }, end: text.length };
+      i = restEnd;
+      continue;
+    }
+    let key;
+    if (ch === '"' || ch === "'") {
+      key = readStringLiteral(text, i).value;
+      i = readStringLiteral(text, i).end;
+    } else {
+      const ident = readIdentifier(text, i);
+      if (ident.end === i) {
+        const skipEnd = scanContainerElementEnd(text, i);
+        if (skipEnd === text.length) return { node: { t: "obj", props }, end: text.length };
+        i = skipEnd;
+        continue;
+      }
+      key = ident.name;
+      i = ident.end;
+    }
+    i = skipTrivia(text, i);
+    if (text[i] === ":") {
+      const valueStart = skipTrivia(text, i + 1);
+      const boundary = scanContainerElementEnd(text, valueStart);
+      const raw = text.slice(valueStart, boundary).trim();
+      let node;
+      try {
+        node = parseValue(raw) || { t: "unresolved", raw };
+      } catch {
+        node = { t: "unresolved", raw };
+      }
+      props.push({ key, value: node, raw });
+      i = boundary;
+    } else {
+      props.push({ key, value: { t: "ident", name: key }, raw: key });
+      i = skipTrivia(text, i);
+      if (text[i] === ",") i += 1;
+    }
+  }
+  return { node: { t: "obj", props }, end: text.length };
+}
+function parseArrayValue(text, index) {
+  const items = [];
+  let i = skipTrivia(text, index + 1);
+  if (text[i] === "]") return { node: { t: "arr", items }, end: i + 1 };
+  while (i < text.length) {
+    i = skipTrivia(text, i);
+    const ch = text[i];
+    if (ch === "]") return { node: { t: "arr", items }, end: i + 1 };
+    if (ch === ",") {
+      i += 1;
+      continue;
+    }
+    const boundary = scanContainerElementEnd(text, i);
+    const raw = text.slice(i, boundary).trim();
+    let node;
+    try {
+      node = parseValue(raw) || { t: "unresolved", raw };
+    } catch {
+      node = { t: "unresolved", raw };
+    }
+    items.push(node);
+    i = boundary;
+  }
+  return { node: { t: "arr", items }, end: text.length };
+}
+function parseValueAt(text, index) {
+  let i = skipTrivia(text, index);
+  const ch = text[i];
+  if (ch === '"' || ch === "'") {
+    const { value, end } = readStringLiteral(text, i);
+    return { node: { t: "str", value }, end };
+  }
+  if (ch === "`") {
+    return parseTemplateValue(text, i);
+  }
+  if (ch === "{") {
+    return parseObjectValue(text, i);
+  }
+  if (ch === "[") {
+    return parseArrayValue(text, i);
+  }
+  if (text.startsWith("new ", i)) {
+    const after = skipTrivia(text, i + 4);
+    const callee = readIdentifier(text, after);
+    if (callee.name.toLowerCase() === "url") {
+      const open = skipTrivia(text, callee.end);
+      if (text[open] === "(") {
+        const argResult = parseValueAt(text, skipTrivia(text, open + 1));
+        return {
+          node: { t: "new-url", arg: argResult.node },
+          end: readBalanced(text, open) + 1
+        };
+      }
+    }
+  }
+  const firstChar = text[i];
+  if (/[A-Za-z_$]/.test(firstChar)) {
+    const ident = readIdentifier(text, i);
+    let node = { t: "ident", name: ident.name };
+    let cursor = ident.end;
+    while (true) {
+      const nxt = skipTrivia(text, cursor);
+      if (text[nxt] === "." || text[nxt] === "?" && text[nxt + 1] === ".") {
+        const dotEnd = text[nxt] === "?" ? nxt + 2 : nxt + 1;
+        const propStart = skipTrivia(text, dotEnd);
+        const prop2 = readIdentifier(text, propStart);
+        if (prop2.end > propStart) {
+          node = { t: "member", object: node, prop: prop2.name };
+          cursor = prop2.end;
+          continue;
+        }
+        break;
+      }
+      if (text[nxt] === "(") {
+        return { node: { t: "unresolved", raw: text.slice(index, readBalanced(text, nxt) + 1) }, end: readBalanced(text, nxt) + 1 };
+      }
+      break;
+    }
+    return { node, end: cursor };
+  }
+  if (/[0-9]/.test(firstChar) || firstChar === "-" && /[0-9]/.test(text[i + 1])) {
+    let cursor = i;
+    while (cursor < text.length && /[0-9.eE_+-]/.test(text[cursor])) cursor += 1;
+    const raw = text.slice(i, cursor);
+    const num = Number(raw.replace(/_/g, ""));
+    return { node: { t: "num", value: Number.isFinite(num) ? num : NaN }, end: cursor };
+  }
+  if (text.startsWith("true", i) || text.startsWith("false", i)) {
+    return { node: { t: "bool", value: text.startsWith("true", i) }, end: i + (text.startsWith("true", i) ? 4 : 5) };
+  }
+  return { node: { t: "unresolved", raw: text.slice(index, i + 1).trim() }, end: i + 1 };
+}
+function parseValue(rawInput) {
+  const text = stripTsSuffix(rawInput);
+  const { node, end } = parseValueAt(text, 0);
+  const rest = skipTrivia(text, end);
+  if (rest < text.length) {
+    let current = node;
+    let cursor = rest;
+    while (true) {
+      cursor = skipTrivia(text, cursor);
+      if (text[cursor] === "+") {
+        const rhs = parseValueAt(text, skipTrivia(text, cursor + 1));
+        if (rhs.node.t === "unresolved" && current.t === "unresolved") break;
+        const parts = [];
+        const collect = (n) => n.t === "concat" ? parts.push(...n.parts) : parts.push(n);
+        collect(current);
+        collect(rhs.node);
+        current = { t: "concat", parts };
+        cursor = rhs.end;
+        continue;
+      }
+      break;
+    }
+    if (cursor >= text.length) return current;
+  }
+  return node;
+}
+
+// ../next-adapter/src/next-metadata.ts
+function prop(node, key) {
+  if (!node || node.t !== "obj") return void 0;
+  const found = node.props.find((p) => p.key === key);
+  if (!found) return void 0;
+  return { value: found.value, raw: found.raw };
+}
+function skipQuoted(text, index) {
+  const quote = text[index];
+  let i = index + 1;
+  while (i < text.length) {
+    if (text[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (quote === "`" && text[i] === "`") return i;
+    if (quote !== "`" && text[i] === quote) return i;
+    if (quote === "`" && text[i] === "$" && text[i + 1] === "{") {
+      const close = text.indexOf("}", i);
+      i = close === -1 ? text.length : close + 1;
+      continue;
+    }
+    i += 1;
+  }
+  return index;
+}
+function flatten(node, path10 = "") {
+  const map = /* @__PURE__ */ new Map();
+  if (node.t !== "obj") return map;
+  for (const p of node.props) {
+    const full = path10 ? `${path10}.${p.key}` : p.key;
+    map.set(full, p.value);
+  }
+  return map;
+}
+function rawOfValue(file, resolver, raw) {
+  if (!resolver) return void 0;
+  const result = resolver.foldExpression(file, raw);
+  if (result.ok && typeof result.value === "string") return result.value;
+  return void 0;
+}
+function fieldFromRaw(file, resolver, raw) {
+  if (raw === void 0) return { declared: false };
+  const value = rawOfValue(file, resolver, raw);
+  return { declared: true, raw, value };
+}
+function robotsFieldFromRaw(raw) {
+  if (raw === void 0) return { declared: false };
+  const parsed = parseValue(raw);
+  if (parsed.t === "str") return { declared: true, raw, value: parsed.value };
+  const value = /noindex|\bindex\s*:\s*false\b/.test(raw) ? "noindex" : "";
+  return { declared: true, raw, value };
+}
+function extractFromObject(file, resolver, rawObject) {
+  let node;
+  try {
+    node = parseValue(rawObject);
+  } catch {
+    node = { t: "unresolved", raw: rawObject };
+  }
+  const props = flatten(node);
+  const titleProp = props.get("title");
+  let title = { declared: false };
+  let titleObject;
+  if (titleProp) {
+    if (titleProp.t === "obj") {
+      const absoluteRaw = prop(titleProp, "absolute")?.raw;
+      const defaultRaw = prop(titleProp, "default")?.raw;
+      const templateRaw = prop(titleProp, "template")?.raw;
+      const absolute = fieldFromRaw(file, resolver, absoluteRaw);
+      const defaultField = fieldFromRaw(file, resolver, defaultRaw);
+      const template = fieldFromRaw(file, resolver, templateRaw);
+      titleObject = { absolute, default: defaultField, template };
+      title = {
+        declared: true,
+        kind: "object",
+        value: absolute.value ?? defaultField.value,
+        raw: absoluteRaw ?? defaultRaw
+      };
+    } else {
+      const value = fieldFromRaw(file, resolver, prop(node, "title")?.raw);
+      title = { ...value, kind: "string" };
+    }
+  } else {
+    titleObject = void 0;
+  }
+  const alternatesNode = props.get("alternates");
+  const canonicalRaw = prop(alternatesNode, "canonical")?.raw ?? prop(node, "canonical")?.raw;
+  return {
+    source: "export-metadata",
+    dynamic: false,
+    hasParams: false,
+    title,
+    titleObject,
+    description: fieldFromRaw(file, resolver, prop(node, "description")?.raw),
+    canonical: fieldFromRaw(file, resolver, canonicalRaw),
+    robots: robotsFieldFromRaw(prop(node, "robots")?.raw),
+    metadataBase: fieldFromRaw(file, resolver, prop(node, "metadataBase")?.raw)
+  };
+}
+function findObjectAfter(content, keywordPattern) {
+  for (const match of content.matchAll(keywordPattern)) {
+    const eq = content.indexOf("=", match.index);
+    if (eq === -1) continue;
+    const brace = content.indexOf("{", eq);
+    if (brace === -1) continue;
+    const end = readBalanced(content, brace);
+    return { raw: content.slice(brace, end + 1), index: brace };
+  }
+  return null;
+}
+function extractNextMetadata(content, file, resolver) {
+  const exportObj = findObjectAfter(content, /export\s+const\s+metadata\b/g);
+  const fnMatch = content.match(/export\s+(?:async\s+)?function\s+generateMetadata\b/g);
+  const fnObj = fnMatch ? findObjectAfter(content, /function\s+generateMetadata\s*\([^)]*\)\s*\{/g) : null;
+  if (!exportObj && !fnMatch) return null;
+  if (exportObj) {
+    return extractFromObject(file, resolver, exportObj.raw);
+  }
+  const candidates = [];
+  const fnAt = content.indexOf("generateMetadata");
+  let hasParams = false;
+  let bodyStart = -1;
+  let bodyEnd = -1;
+  if (fnAt !== -1) {
+    const openParen = content.indexOf("(", fnAt);
+    if (openParen !== -1) {
+      const afterParen = readBalanced(content, openParen) + 1;
+      const signature = content.slice(openParen, afterParen);
+      hasParams = /\b(params|searchParams)\b/.test(signature);
+      let cursor = afterParen;
+      while (cursor < content.length && content[cursor] !== "{") cursor += 1;
+      if (content[cursor] === "{") {
+        bodyStart = cursor;
+        bodyEnd = readBalanced(content, cursor);
+      }
+    }
+  }
+  if (bodyStart !== -1) {
+    let scan = bodyStart + 1;
+    while (scan < bodyEnd) {
+      if (content[scan] === "{") {
+        const end = readBalanced(content, scan);
+        if (end < bodyEnd) candidates.push(content.slice(scan, end + 1));
+        scan = end + 1;
+        continue;
+      }
+      if (content[scan] === '"' || content[scan] === "'") {
+        scan = skipQuoted(content, scan) + 1;
+        continue;
+      }
+      if (content[scan] === "`") {
+        scan = skipQuoted(content, scan) + 1;
+        continue;
+      }
+      scan += 1;
+    }
+  }
+  if (candidates.length === 0) return null;
+  const merged = {
+    source: "generate-metadata",
+    dynamic: true,
+    hasParams,
+    title: { declared: false },
+    description: { declared: false },
+    canonical: { declared: false },
+    robots: { declared: false },
+    metadataBase: { declared: false }
+  };
+  merged.dynamic = hasParams || candidates.length > 1;
+  const prefer = (target, candidate) => {
+    if (!target.declared) return candidate;
+    if (target.value === void 0 && candidate.value !== void 0) return candidate;
+    return target;
+  };
+  for (const raw of candidates) {
+    const extract = extractFromObject(file, resolver, raw);
+    merged.title = prefer(merged.title, extract.title);
+    if (extract.titleObject && (!merged.titleObject || merged.title.value === void 0)) {
+      merged.titleObject = extract.titleObject;
+    }
+    merged.description = prefer(merged.description, extract.description);
+    merged.canonical = prefer(merged.canonical, extract.canonical);
+    merged.robots = prefer(merged.robots, extract.robots);
+    merged.metadataBase = prefer(merged.metadataBase, extract.metadataBase);
+  }
+  return merged;
+}
+function applyTitleTemplate(title, template) {
+  if (!template || !template.includes("%s")) return title;
+  return template.replace(/%s/g, title);
+}
+function buildEffectiveMetadata(extract, inherited, ctx) {
+  const out = { ...inherited };
+  const base = extract.metadataBase.value ?? inherited.metadataBase ?? ctx.origin;
+  if (base) out.metadataBase = base.replace(/\/$/, "");
+  const titleTemplate = extract.titleObject?.template?.value ?? inherited.titleTemplate;
+  if (titleTemplate) out.titleTemplate = titleTemplate;
+  out.titleDeclared = extract.title.declared;
+  if (extract.title.declared) {
+    if (extract.title.kind === "object" || extract.titleObject) {
+      const absolute = extract.titleObject?.absolute?.value;
+      const def = extract.titleObject?.default?.value;
+      const value = absolute ?? def;
+      if (value !== void 0) {
+        out.title = absolute ? value : applyTitleTemplate(value, ctx.isLayout ? void 0 : titleTemplate);
+      } else {
+        out.title = void 0;
+      }
+    } else if (extract.title.value !== void 0) {
+      out.title = ctx.isLayout ? extract.title.value : applyTitleTemplate(extract.title.value, titleTemplate);
+    } else {
+      out.title = void 0;
+    }
+  }
+  out.descriptionDeclared = extract.description.declared;
+  if (extract.description.value !== void 0) out.description = extract.description.value;
+  else if (extract.description.declared) out.description = void 0;
+  out.canonicalDeclared = extract.canonical.declared;
+  if (extract.canonical.value !== void 0) {
+    out.canonical = absolutize(extract.canonical.value, base);
+  } else if (extract.canonical.declared) {
+    out.canonical = void 0;
+  }
+  if (extract.robots.value !== void 0) out.robots = extract.robots.value;
+  out.metadataSource = extract.source;
+  if (extract.dynamic) out.dynamicMetadata = true;
+  return out;
+}
+function absolutize(value, base) {
+  if (/^https?:\/\//i.test(value)) return value;
+  if (value.startsWith("/") && base) {
+    return `${base.replace(/\/$/, "")}${value}`;
+  }
+  return value;
+}
+function resolvePageMetadata(content, file, inherited, ctx) {
+  const extract = extractNextMetadata(content, file, ctx.resolver);
+  if (!extract) {
+    return inherited;
+  }
+  return buildEffectiveMetadata(extract, inherited, { ...ctx, isLayout: false });
+}
+function resolveLayoutMetadata(content, file, ctx) {
+  const extract = extractNextMetadata(content, file, ctx.resolver);
+  if (!extract) return {};
+  return buildEffectiveMetadata(extract, {}, { ...ctx, isLayout: true });
+}
+
+// ../next-adapter/src/dependency-graph.ts
 var RouteDependencyGraph = class {
   projectRoot;
   appDir;
   layoutsByDir = /* @__PURE__ */ new Map();
   routes = [];
-  constructor(projectRoot, appDir) {
+  resolver;
+  origin;
+  constructor(projectRoot, appDir, resolver, origin) {
     this.projectRoot = projectRoot;
     this.appDir = appDir;
+    this.resolver = resolver;
+    this.origin = origin;
   }
   indexLayouts() {
     this.layoutsByDir.clear();
@@ -225,7 +851,7 @@ var RouteDependencyGraph = class {
           }
         } else if (entry.isFile() && /^layout\.(tsx|jsx|js|ts)$/.test(entry.name)) {
           const content = fs.readFileSync(fullPath, "utf8");
-          const parsed = parsePageSource(content, "nextjs");
+          const metadata = this.resolver ? resolveLayoutMetadata(content, fullPath, { resolver: this.resolver, origin: this.origin, file: fullPath }) : parsePageSource(content, "nextjs").metadata;
           const relativeDir = path.relative(this.appDir, currentDir);
           let canonicalLine;
           let robotsLine;
@@ -240,7 +866,7 @@ var RouteDependencyGraph = class {
           this.layoutsByDir.set(relativeDir, {
             filePath: fullPath,
             relativeDir,
-            metadata: parsed.metadata,
+            metadata,
             metadataSourceLocation: {
               canonicalLine,
               robotsLine,
@@ -374,6 +1000,612 @@ var RouteDependencyGraph = class {
   }
 };
 
+// ../next-adapter/src/project-resolver.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function readStringEnd(text, index) {
+  const quote = text[index];
+  let i = index + 1;
+  while (i < text.length) {
+    if (text[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (text[i] === quote) return i + 1;
+    i += 1;
+  }
+  return text.length;
+}
+function splitTopLevelStatements(code) {
+  const out = [];
+  let depth = 0;
+  let statementStart = -1;
+  let i = 0;
+  const flush = (end) => {
+    if (statementStart !== -1) {
+      const raw = code.slice(statementStart, end);
+      if (raw.trim()) out.push({ statement: raw, start: statementStart, end });
+    }
+    statementStart = -1;
+  };
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === " " || ch === "	" || ch === "\r") {
+      if (statementStart === -1 && depth === 0 && out.length === 0 && i < code.length) {
+      }
+      i += 1;
+      continue;
+    }
+    if (ch === "\n") {
+      if (depth === 0) flush(i);
+      i += 1;
+      continue;
+    }
+    if (statementStart === -1) statementStart = i;
+    if (ch === "/" && code[i + 1] === "/") {
+      while (i < code.length && code[i] !== "\n") i += 1;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      i = end === -1 ? code.length : end + 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = readStringEnd(code, i);
+      continue;
+    }
+    if (ch === "`") {
+      let t = i + 1;
+      while (t < code.length) {
+        if (code[t] === "\\") {
+          t += 2;
+          continue;
+        }
+        if (code[t] === "`") break;
+        t += 1;
+      }
+      i = Math.min(t + 1, code.length);
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]" || ch === ")") {
+      depth = Math.max(0, depth - 1);
+    } else if (ch === ";" && depth === 0) {
+      flush(i + 1);
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  flush(code.length);
+  return out;
+}
+var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".svelte"];
+var ProjectResolver = class {
+  projectRoot;
+  cache = /* @__PURE__ */ new Map();
+  aliasRoots = [];
+  loading = /* @__PURE__ */ new Set();
+  origin;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.loadAliases();
+  }
+  loadAliases() {
+    const roots = ["tsconfig.json", "tsconfig.app.json"];
+    for (const name of roots) {
+      const file = path2.join(this.projectRoot, name);
+      if (!fs2.existsSync(file)) continue;
+      try {
+        const json = JSON.parse(fs2.readFileSync(file, "utf8"));
+        const paths = json.compilerOptions?.paths || {};
+        const baseUrl = json.compilerOptions?.baseUrl || ".";
+        for (const [key, targets] of Object.entries(paths)) {
+          if (!key.endsWith("/*") || !Array.isArray(targets)) continue;
+          const dir = path2.resolve(this.projectRoot, baseUrl, String(targets[0]).replace(/\*$/, ""));
+          this.aliasRoots.push({ prefix: key.slice(0, -2), dir });
+        }
+      } catch {
+      }
+    }
+    if (this.aliasRoots.length === 0) {
+      this.aliasRoots.push({ prefix: "@", dir: path2.join(this.projectRoot, "src") });
+    }
+    this.aliasRoots.push({ prefix: "~", dir: path2.join(this.projectRoot, "src") });
+  }
+  readFile(filePath) {
+    try {
+      return fs2.readFileSync(filePath, "utf8");
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Converts a module specifier (relative or `@/`/`~/` alias) into an absolute
+   * path when it points at a resolvable local file.
+   */
+  resolveModule(specifier, fromFile) {
+    let base = specifier;
+    let fromDir = fromFile ? path2.dirname(fromFile) : this.projectRoot;
+    const alias = this.aliasRoots.find((a) => base.startsWith(a.prefix + "/"));
+    if (alias) {
+      fromDir = alias.dir;
+      base = base.slice(alias.prefix.length + 1);
+    } else if (base.startsWith(".")) {
+    } else {
+      return null;
+    }
+    if (!fromDir.startsWith(this.projectRoot)) return null;
+    const candidate = path2.resolve(fromDir, base);
+    return this.resolveAsFile(candidate) || this.resolveAsIndex(candidate);
+  }
+  resolveAsFile(candidate) {
+    if (!fs2.existsSync(candidate)) {
+      for (const ext of EXTENSIONS) {
+        if (fs2.existsSync(candidate + ext)) return candidate + ext;
+      }
+      return null;
+    }
+    const stat = fs2.statSync(candidate);
+    if (stat.isFile()) return candidate;
+    return null;
+  }
+  resolveAsIndex(base) {
+    if (fs2.existsSync(base) && fs2.statSync(base).isDirectory()) {
+      for (const name of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+        const candidate = path2.join(base, name);
+        if (fs2.existsSync(candidate)) return candidate;
+      }
+    }
+    return null;
+  }
+  getModule(filePath) {
+    if (!filePath) return void 0;
+    const normalized = path2.resolve(filePath);
+    const cached = this.cache.get(normalized);
+    if (cached) return cached;
+    const content = this.readFile(normalized);
+    if (content === void 0) return void 0;
+    const info = {
+      filePath: normalized,
+      content,
+      consts: /* @__PURE__ */ new Map(),
+      destructure: /* @__PURE__ */ new Map(),
+      imports: /* @__PURE__ */ new Map(),
+      importsDefault: /* @__PURE__ */ new Map()
+    };
+    this.cache.set(normalized, info);
+    this.parseModule(info);
+    return info;
+  }
+  parseModule(info) {
+    if (info.parsed) return;
+    info.parsed = true;
+    for (const { statement } of splitTopLevelStatements(info.content)) {
+      const stmt = statement.trim();
+      const importMatch = stmt.match(/^import\s+([\s\S]+?)\s+from\s+["']([^"']+)["']/);
+      if (importMatch) {
+        const spec = importMatch[2];
+        const resolved = this.resolveModule(spec, info.filePath);
+        const clause = importMatch[1].trim();
+        const namedBlock = clause.match(/\{([\s\S]*?)\}/);
+        const namedRaw = namedBlock ? namedBlock[1] : "";
+        let defaultName;
+        if (namedBlock) {
+          const before = clause.slice(0, namedBlock.index).replace(/,\s*$/, "").trim();
+          if (/^[A-Za-z_$][\w$]*$/.test(before)) defaultName = before;
+        } else if (/^[A-Za-z_$][\w$]*$/.test(clause)) {
+          defaultName = clause;
+        }
+        if (defaultName) {
+          info.imports.set(defaultName, resolved || spec);
+          info.importsDefault.set(defaultName, resolved || spec);
+        }
+        for (const raw of namedRaw.split(",")) {
+          const pair = raw.trim();
+          if (!pair) continue;
+          const parts = pair.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+          if (parts) info.imports.set(parts[2] || parts[1], resolved || spec);
+        }
+        continue;
+      }
+      const nsImport = stmt.match(/^import\s*\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+["']([^"']+)["']/);
+      if (nsImport) {
+        const resolved = this.resolveModule(nsImport[2], info.filePath);
+        info.imports.set(nsImport[1], resolved || nsImport[2]);
+        continue;
+      }
+      const constStmt = stmt.match(/^(?:export\s+|declare\s+)?const\s+([\s\S]+?)=\s*([\s\S]+)$/);
+      if (constStmt) {
+        const lhs = constStmt[1].trim();
+        const rawValue = constStmt[2].trim().replace(/;\s*$/, "");
+        if (lhs.startsWith("{") || lhs.startsWith("[")) {
+          const names = [...lhs.matchAll(/([A-Za-z_$][\w$]*)(?:\s*:\s*([A-Za-z_$][\w$]*))?/g)];
+          for (const name of names) {
+            const sourceProp = name[1];
+            const target = name[2] || sourceProp;
+            info.destructure.set(target, `${rawValue}.${sourceProp}`);
+          }
+        } else if (/^[A-Za-z_$][\w$]*$/.test(lhs)) {
+          info.consts.set(lhs, rawValue);
+        }
+        continue;
+      }
+      const exportMatch = stmt.match(/^export\s+default\s+([\s\S]+)$/);
+      if (exportMatch) {
+        info.defaultRaw = exportMatch[1].trim().replace(/;\s*$/, "");
+      }
+    }
+  }
+  /**
+   * Looks up an identifier's raw expression within `file`, following imports,
+   * module destructuring, and default-export bindings.
+   */
+  resolveIdentifier(file, name) {
+    const info = this.getModule(file);
+    if (!info) return void 0;
+    if (info.destructure.has(name)) return info.destructure.get(name);
+    if (info.consts.has(name)) return info.consts.get(name);
+    const importedFrom = info.imports.get(name);
+    if (!importedFrom) return void 0;
+    const targetModule = this.getModule(importedFrom);
+    if (!targetModule) return void 0;
+    if (targetModule.consts.has(name)) return targetModule.consts.get(name);
+    if (info.importsDefault.has(name) && targetModule.defaultRaw !== void 0) {
+      return targetModule.defaultRaw;
+    }
+    return void 0;
+  }
+  /** Folds an expression string in the context of `file`. */
+  foldExpression(file, raw) {
+    let node;
+    try {
+      node = parseValue(raw);
+    } catch {
+      return { ok: false, unresolved: [raw.trim().slice(0, 80)] };
+    }
+    const state = { ok: true };
+    const value = this.foldNode(file, node, /* @__PURE__ */ new Set(), state);
+    if (!state.ok) {
+      return { ok: false, value, unresolved: state.unresolved };
+    }
+    return { ok: true, value };
+  }
+  foldNode(file, node, seen, state) {
+    switch (node.t) {
+      case "str":
+        return node.value;
+      case "num":
+        return node.value;
+      case "bool":
+        return node.value;
+      case "template": {
+        let out = "";
+        for (const part of node.parts) {
+          if (part.t === "str") {
+            out += part.value;
+            continue;
+          }
+          const folded = this.foldNode(file, part, seen, state);
+          if (typeof folded === "string") out += folded;
+          else if (typeof folded === "number" || typeof folded === "boolean") out += String(folded);
+          else {
+            state.ok = false;
+            (state.unresolved = state.unresolved || []).push(node.raw.slice(0, 60));
+            return void 0;
+          }
+        }
+        return out;
+      }
+      case "concat": {
+        let out = "";
+        for (const part of node.parts) {
+          const folded = this.foldNode(file, part, seen, state);
+          if (typeof folded === "string") out += folded;
+          else if (typeof folded === "number" || typeof folded === "boolean") out += String(folded);
+          else {
+            state.ok = false;
+            (state.unresolved = state.unresolved || []).push("concat");
+            return void 0;
+          }
+        }
+        return out;
+      }
+      case "new-url": {
+        const folded = this.foldNode(file, node.arg, seen, state);
+        return typeof folded === "string" ? folded : (state.ok = false, void 0);
+      }
+      case "ident": {
+        if (node.name === "undefined") return void 0;
+        if (seen.has(node.name)) {
+          state.ok = false;
+          (state.unresolved = state.unresolved || []).push(node.name);
+          return void 0;
+        }
+        const raw = this.resolveIdentifier(file, node.name);
+        if (raw === void 0) {
+          state.ok = false;
+          (state.unresolved = state.unresolved || []).push(node.name);
+          return void 0;
+        }
+        const nextSeen = new Set(seen);
+        nextSeen.add(node.name);
+        let sub;
+        try {
+          sub = parseValue(raw);
+        } catch {
+          state.ok = false;
+          return void 0;
+        }
+        return this.foldNode(file, sub, nextSeen, state);
+      }
+      case "member": {
+        const prevOk = state.ok;
+        const prevUnresolved = state.unresolved ? state.unresolved.slice() : [];
+        const object = this.foldNode(file, node.object, seen, state);
+        const isRecord = object !== null && object !== void 0 && typeof object === "object" && !Array.isArray(object);
+        if (isRecord) {
+          const record = object;
+          if (node.prop in record && record[node.prop] !== void 0) {
+            if (!state.ok) {
+              state.ok = true;
+              if (state.unresolved) state.unresolved = prevUnresolved;
+            }
+            return record[node.prop];
+          }
+        }
+        state.ok = prevOk;
+        state.unresolved = prevUnresolved;
+        (state.unresolved = state.unresolved || []).push(node.object.t === "ident" ? `${node.object.name}.${node.prop}` : `.${node.prop}`);
+        return void 0;
+      }
+      case "arr": {
+        const items = [];
+        for (const item of node.items) {
+          items.push(this.foldNode(file, item, seen, state));
+        }
+        return items;
+      }
+      case "obj": {
+        const record = {};
+        for (const prop2 of node.props) {
+          record[prop2.key] = this.foldNode(file, prop2.value, seen, state);
+        }
+        return record;
+      }
+      case "unresolved":
+        state.ok = false;
+        (state.unresolved = state.unresolved || []).push(node.raw.slice(0, 60));
+        return void 0;
+    }
+  }
+  /** Reads raw const initializer by name in file (for generateStaticParams etc.). */
+  rawConst(file, name) {
+    return this.resolveIdentifier(file, name);
+  }
+  /** Reads the default export expression of a module. */
+  defaultExport(file) {
+    return this.getModule(file)?.defaultRaw;
+  }
+  /**
+   * Best-effort guess of the production origin (scheme + host) by scanning
+   * common configuration modules and the root layout for an http(s) URL that
+   * is clearly not a placeholder.
+   */
+  guessOrigin(knownUrls = []) {
+    if (this.origin) return this.origin;
+    const candidates = [...knownUrls];
+    const filesToScan = [
+      path2.join(this.projectRoot, "config", "site.ts"),
+      path2.join(this.projectRoot, "config", "site.tsx"),
+      path2.join(this.projectRoot, "lib", "site.ts"),
+      path2.join(this.projectRoot, "src", "config", "site.ts"),
+      path2.join(this.projectRoot, "src", "config", "site.tsx"),
+      path2.join(this.projectRoot, "src", "lib", "site.ts"),
+      path2.join(this.projectRoot, "src", "app", "layout.tsx"),
+      path2.join(this.projectRoot, "app", "layout.tsx"),
+      path2.join(this.projectRoot, "package.json")
+    ];
+    for (const file of filesToScan) {
+      const content = this.readFile(file);
+      if (!content) continue;
+      for (const m of content.matchAll(/https?:\/\/[A-Za-z0-9.-]+(?::\d+)?/g)) {
+        candidates.push(m[0]);
+      }
+    }
+    const preferred = candidates.find(
+      (u) => /^https:/.test(u) && !/example\.|localhost|127\.0\.0\.1|test\.|\.invalid/i.test(u)
+    );
+    const fallback = candidates.find((u) => !/example\.|localhost|127\.0\.0\.1|test\.|\.invalid/i.test(u));
+    const chosen = preferred || fallback;
+    if (chosen) {
+      try {
+        this.origin = new URL(chosen).origin;
+      } catch {
+        this.origin = void 0;
+      }
+    }
+    return this.origin;
+  }
+  /** Parses a project file into an AST-slim statement list (for heading discovery). */
+  readModuleFile(filePath) {
+    const info = this.getModule(filePath);
+    return info?.content;
+  }
+};
+
+// ../next-adapter/src/enrich.ts
+function stringLiterals(text) {
+  const out = [];
+  for (const m of text.matchAll(/["'`]([^"'`\n]{1,200})["'`]/g)) out.push(m[1]);
+  return out;
+}
+function headingRegexFor(level) {
+  return new RegExp(`<h${level}\\b[^>]*>([\\s\\S]*?)</h${level}>`, "gi");
+}
+function stripTags(text) {
+  return text.replace(/<[^>]+>/g, "").replace(/\{[^{}]*\}/g, " ").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\s+/g, " ").trim();
+}
+function lineAt2(text, index) {
+  return text.slice(0, index).split("\n").length;
+}
+function collectInlineHeadings(content) {
+  const headings = [];
+  for (let level = 1; level <= 6; level += 1) {
+    const re = headingRegexFor(level);
+    for (const match of content.matchAll(re)) {
+      headings.push({ level, text: stripTags(match[1]), line: lineAt2(content, match.index || 0) });
+    }
+  }
+  return headings.sort((a, b) => (a.line || 0) - (b.line || 0));
+}
+function localComponentImports(content, fromFile, resolver) {
+  const files = [];
+  for (const m of content.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) {
+    const spec = m[1];
+    const resolved = resolver.resolveModule(spec, fromFile);
+    if (resolved) files.push(resolved);
+  }
+  return files;
+}
+function fileHasFlag(content, flag) {
+  const re = new RegExp(`\\b${flag}\\s*=\\s*false\\b`);
+  return re.test(content);
+}
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function addSlugCandidates(params, values) {
+  for (const literal of values) {
+    if (SLUG_RE.test(literal) && literal.length <= 64) params.add(literal);
+  }
+}
+function dynamicParamsForFile(filePath, resolver) {
+  const content = resolver.readModuleFile(filePath);
+  if (content === void 0) return { dynamicParams: void 0, generatedParams: [] };
+  const dynamicParams = fileHasFlag(content, "dynamicParams") ? false : void 0;
+  const params = /* @__PURE__ */ new Set();
+  const fnIdx = content.search(/generateStaticParams\s*\(/);
+  if (fnIdx !== -1) {
+    const bodyStart = content.indexOf("{", fnIdx);
+    if (bodyStart !== -1) {
+      const bodyEnd = readBalanced(content, bodyStart);
+      const body = content.slice(bodyStart, bodyEnd);
+      addSlugCandidates(params, stringLiterals(body));
+    }
+  }
+  const visitedFiles = /* @__PURE__ */ new Set([filePath]);
+  const queue = [];
+  const enqueueFile = (file, depth) => {
+    if (!visitedFiles.has(file) && depth <= 4) queue.push({ file, depth });
+  };
+  for (const m of content.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) {
+    const resolved = resolver.resolveModule(m[1], filePath);
+    if (resolved) enqueueFile(resolved, 1);
+  }
+  let budget = 400;
+  while (queue.length > 0 && budget > 0) {
+    budget -= 1;
+    const { file, depth } = queue.shift();
+    if (visitedFiles.has(file)) continue;
+    visitedFiles.add(file);
+    const nextContent = resolver.readModuleFile(file);
+    if (nextContent === void 0) continue;
+    addSlugCandidates(params, stringLiterals(nextContent));
+    for (const match of nextContent.matchAll(/(?:^|\n)\s*(?:export\s+)?const\s+[A-Za-z_$][\w$]*\s*(?::[^=\n]+)?=\s*\[/g)) {
+      const open = nextContent.indexOf("[", match.index);
+      if (open === -1) continue;
+      const end = readBalanced(nextContent, open);
+      const arrBody = nextContent.slice(open, end + 1);
+      addSlugCandidates(params, stringLiterals(arrBody));
+    }
+    for (const match of nextContent.matchAll(/(?:\bslug\s*|\bid\s*|\bkind\s*|\bhref\s*)\s*:\s*["']([^"'\n]+)["']/g)) {
+      addSlugCandidates(params, [match[1]]);
+    }
+    if (depth < 4) {
+      for (const m of nextContent.matchAll(/import[\s\S]*?from\s+["']([^"']+)["']/g)) {
+        const resolved = resolver.resolveModule(m[1], file);
+        if (resolved) enqueueFile(resolved, depth + 1);
+      }
+    }
+  }
+  return { dynamicParams, generatedParams: Array.from(params) };
+}
+function discoverImportedH1(filePath, resolver, maxDepth = 3) {
+  const content = resolver.readModuleFile(filePath);
+  if (content === void 0) return [];
+  const visited = /* @__PURE__ */ new Set([filePath]);
+  const result = [];
+  const queue = localComponentImports(content, filePath, resolver).map(
+    (file) => ({ file, depth: 1 })
+  );
+  while (queue.length > 0) {
+    const { file, depth } = queue.shift();
+    if (depth > maxDepth || visited.has(file)) continue;
+    visited.add(file);
+    const nextContent = resolver.readModuleFile(file);
+    if (nextContent === void 0) continue;
+    const h1s = collectInlineHeadings(nextContent).filter((h) => h.level === 1);
+    if (h1s.length > 0) {
+      result.push(h1s[0]);
+      continue;
+    }
+    for (const next of localComponentImports(nextContent, file, resolver)) {
+      queue.push({ file: next, depth: depth + 1 });
+    }
+  }
+  return result;
+}
+function findDefaultExportBody(content) {
+  const idx = content.search(/export\s+default\b/);
+  if (idx === -1) return null;
+  const head = content.slice(idx);
+  if (/export\s+default\s+(?:async\s+)?function\b/.test(head)) {
+    const openParen = head.indexOf("(", head.indexOf("function"));
+    if (openParen === -1) return null;
+    let cursor = readBalanced(head, openParen) + 1;
+    while (cursor < head.length && head[cursor] !== "{") cursor += 1;
+    if (head[cursor] !== "{") return null;
+    const end = readBalanced(head, cursor);
+    return { start: idx + cursor, end: idx + end };
+  }
+  const arrow = head.indexOf("=>");
+  if (arrow !== -1) {
+    let cursor = arrow + 2;
+    while (cursor < head.length && /\s/.test(head[cursor])) cursor += 1;
+    if (head[cursor] === "{") {
+      const end = readBalanced(head, cursor);
+      return { start: idx + cursor, end: idx + end };
+    }
+  }
+  return null;
+}
+function computeH1Concurrency(content, h1Lines) {
+  const body = findDefaultExportBody(content);
+  if (!body) return null;
+  const { start, end } = body;
+  const blockStarts = [];
+  const returnRe = /(?:^|[^A-Za-z0-9_$])return\s*(?:\(\s*)?</g;
+  for (const match of content.slice(start, end).matchAll(returnRe)) {
+    const absolute = start + (match.index || 0);
+    blockStarts.push(lineAt2(content, absolute));
+  }
+  if (blockStarts.length === 0) return null;
+  blockStarts.sort((a, b) => a - b);
+  const counts = /* @__PURE__ */ new Map();
+  for (const h1Line of h1Lines) {
+    let owner = blockStarts[0];
+    for (const block of blockStarts) {
+      if (block <= h1Line) owner = block;
+      else break;
+    }
+    counts.set(owner, (counts.get(owner) || 0) + 1);
+  }
+  let max = 0;
+  for (const count of counts.values()) max = Math.max(max, count);
+  return max;
+}
+
 // ../next-adapter/src/scanner.ts
 function normalizeRouteGroup(segment) {
   return segment.startsWith("(") && segment.endsWith(")") ? "" : segment;
@@ -383,39 +1615,39 @@ var NextJsAdapter = class {
    * Detects if the given directory contains a Next.js application.
    */
   static async detect(projectRoot) {
-    const pkgPath = path2.join(projectRoot, "package.json");
-    if (fs2.existsSync(pkgPath)) {
+    const pkgPath = path3.join(projectRoot, "package.json");
+    if (fs3.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
         const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
         if (deps.next) return true;
       } catch {
       }
     }
-    return fs2.existsSync(path2.join(projectRoot, "app")) || fs2.existsSync(path2.join(projectRoot, "src", "app")) || fs2.existsSync(path2.join(projectRoot, "pages")) || fs2.existsSync(path2.join(projectRoot, "src", "pages")) || fs2.existsSync(path2.join(projectRoot, "next.config.js")) || fs2.existsSync(path2.join(projectRoot, "next.config.mjs"));
+    return fs3.existsSync(path3.join(projectRoot, "app")) || fs3.existsSync(path3.join(projectRoot, "src", "app")) || fs3.existsSync(path3.join(projectRoot, "pages")) || fs3.existsSync(path3.join(projectRoot, "src", "pages")) || fs3.existsSync(path3.join(projectRoot, "next.config.js")) || fs3.existsSync(path3.join(projectRoot, "next.config.mjs"));
   }
   /**
    * Loads optional seo.config.ts or returns default configuration.
    */
   static async loadConfig(projectRoot) {
     const configCandidates = [
-      path2.join(projectRoot, "crawlemon.config.ts"),
-      path2.join(projectRoot, "crawlemon.config.js"),
-      path2.join(projectRoot, "crawlemon.config.mjs"),
-      path2.join(projectRoot, "crawlemon.config.json"),
-      path2.join(projectRoot, "crawlemon.yml"),
-      path2.join(projectRoot, "crawlemon.yaml"),
-      path2.join(projectRoot, "seo.config.ts"),
-      path2.join(projectRoot, "seo.config.js"),
-      path2.join(projectRoot, "seo.config.json")
+      path3.join(projectRoot, "crawlemon.config.ts"),
+      path3.join(projectRoot, "crawlemon.config.js"),
+      path3.join(projectRoot, "crawlemon.config.mjs"),
+      path3.join(projectRoot, "crawlemon.config.json"),
+      path3.join(projectRoot, "crawlemon.yml"),
+      path3.join(projectRoot, "crawlemon.yaml"),
+      path3.join(projectRoot, "seo.config.ts"),
+      path3.join(projectRoot, "seo.config.js"),
+      path3.join(projectRoot, "seo.config.json")
     ];
     for (const candidate of configCandidates) {
-      if (fs2.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         try {
           if (candidate.endsWith(".json")) {
-            return JSON.parse(fs2.readFileSync(candidate, "utf8"));
+            return JSON.parse(fs3.readFileSync(candidate, "utf8"));
           }
-          const content = fs2.readFileSync(candidate, "utf8");
+          const content = fs3.readFileSync(candidate, "utf8");
           const siteUrlMatch = content.match(/siteUrl\s*:\s*["']([^"']+)["']/);
           const ignoreMatch = content.match(/ignore\s*:\s*\[([\s\S]*?)\]/);
           const ignore = ignoreMatch ? Array.from(ignoreMatch[1].matchAll(/["']([^"']+)["']/g), (match) => match[1]) : void 0;
@@ -463,61 +1695,80 @@ var NextJsAdapter = class {
   static async scan(projectRoot) {
     const isNext = await this.detect(projectRoot);
     const config = await this.loadConfig(projectRoot);
-    let appDir = path2.join(projectRoot, "app");
-    if (!fs2.existsSync(appDir) && fs2.existsSync(path2.join(projectRoot, "src", "app"))) {
-      appDir = path2.join(projectRoot, "src", "app");
+    let appDir = path3.join(projectRoot, "app");
+    if (!fs3.existsSync(appDir) && fs3.existsSync(path3.join(projectRoot, "src", "app"))) {
+      appDir = path3.join(projectRoot, "src", "app");
     }
-    let pagesDir = path2.join(projectRoot, "pages");
-    if (!fs2.existsSync(pagesDir) && fs2.existsSync(path2.join(projectRoot, "src", "pages"))) {
-      pagesDir = path2.join(projectRoot, "src", "pages");
+    let pagesDir = path3.join(projectRoot, "pages");
+    if (!fs3.existsSync(pagesDir) && fs3.existsSync(path3.join(projectRoot, "src", "pages"))) {
+      pagesDir = path3.join(projectRoot, "src", "pages");
     }
-    const isAppRouter = fs2.existsSync(appDir);
+    const isAppRouter = fs3.existsSync(appDir);
     const routes = [];
     const redirects = [];
     for (const configName of ["next.config.js", "next.config.mjs", "next.config.ts"]) {
-      const configPath = path2.join(projectRoot, configName);
-      if (!fs2.existsSync(configPath)) continue;
-      const content = fs2.readFileSync(configPath, "utf8");
+      const configPath = path3.join(projectRoot, configName);
+      if (!fs3.existsSync(configPath)) continue;
+      const content = fs3.readFileSync(configPath, "utf8");
       for (const match of content.matchAll(/source\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,500}?destination\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,200}?permanent\s*:\s*(true|false)/g)) {
         redirects.push({ source: match[1], destination: match[2], permanent: match[3] === "true" });
       }
       break;
     }
-    const dependencyGraph = isAppRouter ? new RouteDependencyGraph(projectRoot, appDir) : void 0;
+    const resolver = isAppRouter ? new ProjectResolver(projectRoot) : void 0;
+    const origin = resolveProjectOrigin(config, resolver);
+    const dependencyGraph = isAppRouter ? new RouteDependencyGraph(projectRoot, appDir, resolver, origin) : void 0;
     if (dependencyGraph) {
       dependencyGraph.indexLayouts();
     }
     if (isAppRouter) {
       const scanAppDir = (currentDir, relativePath = "") => {
-        const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path2.join(currentDir, entry.name);
+          const fullPath = path3.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
               continue;
             }
             const normalized = normalizeRouteGroup(entry.name);
-            const nextRelative = normalized ? path2.join(relativePath, normalized) : relativePath;
+            const nextRelative = normalized ? path3.join(relativePath, normalized) : relativePath;
             scanAppDir(fullPath, nextRelative);
           } else if (entry.isFile()) {
             if (/^page\.(tsx|jsx|js|ts)$/.test(entry.name)) {
               const routePath = relativePath === "" ? "/" : `/${relativePath.replace(/\\/g, "/")}`;
-              const content = fs2.readFileSync(fullPath, "utf8");
+              const content = fs3.readFileSync(fullPath, "utf8");
               const parsed = parsePageSource(content);
               const inheritedMetadata = dependencyGraph ? dependencyGraph.getInheritedMetadata(fullPath) : {};
+              let metadata = resolver ? resolvePageMetadata(content, fullPath, inheritedMetadata, { resolver, origin, file: fullPath }) : { ...inheritedMetadata, ...parsed.metadata };
+              if (parsed.metadata.hasConflictingDeclarations) metadata.hasConflictingDeclarations = true;
+              if (parsed.metadata.jsonLd) metadata.jsonLd = parsed.metadata.jsonLd;
+              const headings = [...parsed.headings];
+              if (!headings.some((h) => h.level === 1) && resolver) {
+                headings.push(...discoverImportedH1(fullPath, resolver));
+              }
+              const dynamic = resolver ? dynamicParamsForFile(fullPath, resolver) : void 0;
+              const inlineH1 = parsed.headings.filter((h) => h.level === 1);
+              let maxConcurrentH1;
+              if (inlineH1.length > 0) {
+                const concurrency = computeH1Concurrency(content, inlineH1.map((h) => h.line || 0));
+                maxConcurrentH1 = concurrency === null ? inlineH1.length : concurrency;
+              } else {
+                maxConcurrentH1 = headings.filter((h) => h.level === 1).length;
+              }
               routes.push({
                 route: routePath,
                 filePath: fullPath,
-                metadata: {
-                  ...inheritedMetadata,
-                  ...parsed.metadata
-                },
-                headings: parsed.headings,
+                metadata,
+                headings,
                 images: parsed.images,
                 links: parsed.links,
                 textContent: parsed.textContent,
                 hasLittleContent: parsed.hasLittleContent,
-                hasDynamicSegments: routePath.includes("[")
+                hasDynamicSegments: routePath.includes("["),
+                dynamicParams: dynamic?.dynamicParams,
+                generatedParams: dynamic?.generatedParams,
+                isRedirect: isRedirectOnly(content),
+                maxConcurrentH1
               });
             }
           }
@@ -525,26 +1776,29 @@ var NextJsAdapter = class {
       };
       scanAppDir(appDir);
     }
-    if (fs2.existsSync(pagesDir)) {
+    if (fs3.existsSync(pagesDir)) {
       const scanPagesDir = (currentDir, relativePath = "") => {
-        const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path2.join(currentDir, entry.name);
+          const fullPath = path3.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
               continue;
             }
-            scanPagesDir(fullPath, path2.join(relativePath, entry.name));
+            scanPagesDir(fullPath, path3.join(relativePath, entry.name));
           } else if (entry.isFile()) {
             if (/\.(tsx|jsx|js)$/.test(entry.name)) {
               const baseName = entry.name.replace(/\.(tsx|jsx|js)$/, "");
               if (baseName.startsWith("_") || baseName === "api") {
                 continue;
               }
-              let routePath = `/${path2.join(relativePath, baseName === "index" ? "" : baseName).replace(/\\/g, "/")}`;
+              let routePath = `/${path3.join(relativePath, baseName === "index" ? "" : baseName).replace(/\\/g, "/")}`;
               if (routePath === "//" || routePath === "") routePath = "/";
-              const content = fs2.readFileSync(fullPath, "utf8");
+              const content = fs3.readFileSync(fullPath, "utf8");
               const parsed = parsePageSource(content);
+              const inlineH1 = parsed.headings.filter((h) => h.level === 1);
+              const concurrency = computeH1Concurrency(content, inlineH1.map((h) => h.line || 0));
+              const maxConcurrentH1 = concurrency === null ? inlineH1.length : concurrency;
               routes.push({
                 route: routePath,
                 filePath: fullPath,
@@ -554,7 +1808,8 @@ var NextJsAdapter = class {
                 links: parsed.links,
                 textContent: parsed.textContent,
                 hasLittleContent: parsed.hasLittleContent,
-                hasDynamicSegments: routePath.includes("[")
+                hasDynamicSegments: routePath.includes("["),
+                maxConcurrentH1
               });
             }
           }
@@ -563,36 +1818,36 @@ var NextJsAdapter = class {
       scanPagesDir(pagesDir);
     }
     const sitemapCandidates = [
-      path2.join(appDir, "sitemap.ts"),
-      path2.join(appDir, "sitemap.js"),
-      path2.join(projectRoot, "public", "sitemap.xml")
+      path3.join(appDir, "sitemap.ts"),
+      path3.join(appDir, "sitemap.js"),
+      path3.join(projectRoot, "public", "sitemap.xml")
     ];
     let sitemapFound = false;
     let sitemapMalformed = false;
     const sitemapUrls = [];
     for (const candidate of sitemapCandidates) {
-      if (fs2.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         sitemapFound = true;
-        const content = fs2.readFileSync(candidate, "utf8");
+        const content = fs3.readFileSync(candidate, "utf8");
         if (candidate.endsWith(".xml") && (!/<urlset\b/i.test(content) || !/<loc>[^<]+<\/loc>/i.test(content))) {
           sitemapMalformed = true;
         }
-        const urlMatches = content.matchAll(/url\s*:\s*['"`]([^'"`]+)['"`]|<loc>([^<]+)<\/loc>/gi);
-        for (const m of urlMatches) {
-          const url = m[1] || m[2];
-          if (url) sitemapUrls.push(url.trim());
+        if (candidate.endsWith(".xml")) {
+          for (const m of content.matchAll(/<loc>([^<]+)<\/loc>/gi)) sitemapUrls.push(m[1].trim());
+        } else {
+          resolveTsSitemapUrls(content, candidate, resolver, sitemapUrls, origin);
         }
         break;
       }
     }
     const robotsCandidates = [
-      path2.join(appDir, "robots.ts"),
-      path2.join(appDir, "robots.js"),
-      path2.join(projectRoot, "public", "robots.txt")
+      path3.join(appDir, "robots.ts"),
+      path3.join(appDir, "robots.js"),
+      path3.join(projectRoot, "public", "robots.txt")
     ];
-    const robotsFile = robotsCandidates.find((candidate) => fs2.existsSync(candidate));
+    const robotsFile = robotsCandidates.find((candidate) => fs3.existsSync(candidate));
     const robotsFound = Boolean(robotsFile);
-    const robotsContent = robotsFile ? fs2.readFileSync(robotsFile, "utf8") : "";
+    const robotsContent = robotsFile ? fs3.readFileSync(robotsFile, "utf8") : "";
     routes.sort((a, b) => a.route.localeCompare(b.route));
     if (dependencyGraph) {
       dependencyGraph.setRoutes(routes);
@@ -613,10 +1868,64 @@ var NextJsAdapter = class {
     };
   }
 };
+function resolveProjectOrigin(config, resolver) {
+  if (config.siteUrl) {
+    try {
+      const url = new URL(config.siteUrl);
+      if (url.protocol === "http:" || url.protocol === "https:") return url.origin;
+    } catch {
+    }
+  }
+  return resolver ? resolver.guessOrigin(config.siteUrl ? [config.siteUrl] : []) : void 0;
+}
+function isRedirectOnly(content) {
+  const usesNextNavigation = /from\s+["']next\/navigation["']/.test(content);
+  if (!usesNextNavigation) return false;
+  const hasRedirectCall = /\b(redirect|permanentRedirect)\s*\(/.test(content);
+  if (!hasRedirectCall) return false;
+  return !/<[A-Za-z]/.test(content);
+}
+function resolveTsSitemapUrls(content, file, resolver, out, origin) {
+  const foldWithOrigin = (raw) => {
+    if (!resolver) return void 0;
+    const direct = resolver.foldExpression(file, raw);
+    if (direct.ok && typeof direct.value === "string" && direct.value) return direct.value;
+    if (!origin) return void 0;
+    const substituted = raw.replace(/\$\{\s*([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)\s*\}/g, (whole, inner) => {
+      const last = inner.split(/\.|\s/).pop() || "";
+      if (last === "url" || last === "origin" || last === "URL" || /^siteUrl$/i.test(inner)) return origin;
+      return whole;
+    }).replace(/\b(?:siteConfig|siteURL|siteUrl)\.url\b/g, origin);
+    const retry = resolver.foldExpression(file, substituted);
+    if (retry.ok && typeof retry.value === "string" && retry.value) return retry.value;
+    return void 0;
+  };
+  const pushExpressionUrl = (start) => {
+    const i = skipTrivia(content, start);
+    if (i >= content.length) return;
+    const { end } = parseValueAt(content, i);
+    if (end <= i) return;
+    const raw = content.slice(i, end).trim();
+    const value = foldWithOrigin(raw);
+    if (value) out.push(value);
+  };
+  let search = 0;
+  while (search < content.length) {
+    const idx = content.indexOf("url:", search);
+    if (idx === -1) break;
+    const before = content.slice(Math.max(0, idx - 1), idx);
+    if (!/[{,:\s]/.test(before) || /[A-Za-z0-9_$]/.test(before)) {
+      search = idx + 1;
+      continue;
+    }
+    pushExpressionUrl(idx + "url:".length);
+    search = idx + "url:".length;
+  }
+}
 
 // ../next-adapter/src/framework-adapter.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 var INHERITED_METADATA_FIELDS = ["title", "description", "canonical", "robots"];
 var LABELS = {
   nextjs: "Next.js",
@@ -629,23 +1938,23 @@ var LABELS = {
 };
 function dependencies(root) {
   try {
-    const pkg = JSON.parse(fs3.readFileSync(path3.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs4.readFileSync(path4.join(root, "package.json"), "utf8"));
     return { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
   } catch {
     return {};
   }
 }
 function walk(dir, visit) {
-  if (!fs3.existsSync(dir)) return;
-  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs4.existsSync(dir)) return;
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || ["node_modules", "dist", "build", ".output"].includes(entry.name)) continue;
-    const full = path3.join(dir, entry.name);
+    const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) walk(full, visit);
     else if (entry.isFile()) visit(full);
   }
 }
 function routeNode(file, route, framework) {
-  const parsed = parsePageSource(fs3.readFileSync(file, "utf8"), framework);
+  const parsed = parsePageSource(fs4.readFileSync(file, "utf8"), framework);
   return { route, filePath: file, ...parsed, hasDynamicSegments: /[:[*]/.test(route) };
 }
 function cleanRoute(value) {
@@ -657,27 +1966,27 @@ function discoverRoutes(root, framework) {
   const routes = [];
   const add = (base, extensions, convert) => {
     walk(base, (file) => {
-      const relative = path3.relative(base, file);
+      const relative = path4.relative(base, file);
       if (!extensions.test(relative) || /(^|\/)api(\/|\.|$)/.test(relative)) return;
       routes.push(routeNode(file, convert(relative), framework));
     });
   };
   if (framework === "nuxt") {
-    const base = fs3.existsSync(path3.join(root, "pages")) ? path3.join(root, "pages") : path3.join(root, "app", "pages");
+    const base = fs4.existsSync(path4.join(root, "pages")) ? path4.join(root, "pages") : path4.join(root, "app", "pages");
     add(base, /\.vue$/, (r) => cleanRoute(r.replace(/\.vue$/, "").replace(/\[\.\.\.([^\]]+)\]/g, "*$1").replace(/\[([^\]]+)\]/g, ":$1")));
   } else if (framework === "sveltekit") {
-    const base = path3.join(root, "src", "routes");
+    const base = path4.join(root, "src", "routes");
     add(base, /(^|\/)\+page\.svelte$/, (r) => cleanRoute(r.replace(/\/\+page\.svelte$/, "").replace(/^\+page\.svelte$/, "")));
   } else if (framework === "astro") {
-    const base = path3.join(root, "src", "pages");
+    const base = path4.join(root, "src", "pages");
     add(base, /\.(astro|md|mdx)$/, (r) => cleanRoute(r.replace(/\.(astro|md|mdx)$/, "")));
   } else if (framework === "remix") {
-    const base = path3.join(root, "app", "routes");
+    const base = path4.join(root, "app", "routes");
     add(base, /\.(tsx|jsx|ts|js)$/, (r) => cleanRoute(r.replace(/\.(tsx|jsx|ts|js)$/, "").replace(/\._index$/, "").replace(/^_index$/, "").replace(/\./g, "/").replace(/\$([^/]+)/g, ":$1")));
   } else if (framework === "vite") {
     for (const candidate of ["src/App.tsx", "src/App.jsx", "src/App.vue", "src/App.svelte", "index.html"]) {
-      const file = path3.join(root, candidate);
-      if (fs3.existsSync(file)) routes.push(routeNode(file, "/", framework));
+      const file = path4.join(root, candidate);
+      if (fs4.existsSync(file)) routes.push(routeNode(file, "/", framework));
     }
   } else {
     add(root, /\.html?$/, (r) => cleanRoute(r.replace(/\.html?$/, "")));
@@ -687,30 +1996,30 @@ function discoverRoutes(root, framework) {
 }
 function svelteKitLayouts(root) {
   const layoutByDir = /* @__PURE__ */ new Map();
-  const base = path3.join(root, "src", "routes");
+  const base = path4.join(root, "src", "routes");
   const readLayout = (dir) => {
-    const layoutFile = path3.join(dir, "+layout.svelte");
-    if (fs3.existsSync(layoutFile)) {
-      layoutByDir.set(dir, parsePageSource(fs3.readFileSync(layoutFile, "utf8"), "sveltekit").metadata);
+    const layoutFile = path4.join(dir, "+layout.svelte");
+    if (fs4.existsSync(layoutFile)) {
+      layoutByDir.set(dir, parsePageSource(fs4.readFileSync(layoutFile, "utf8"), "sveltekit").metadata);
     }
-    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        readLayout(path3.join(dir, entry.name));
+        readLayout(path4.join(dir, entry.name));
       }
     }
   };
-  if (fs3.existsSync(base)) readLayout(base);
+  if (fs4.existsSync(base)) readLayout(base);
   return layoutByDir;
 }
 function mergeLayoutMetadata(routes, framework, root) {
   if (framework !== "sveltekit") return routes;
   const layoutByDir = svelteKitLayouts(root);
   if (layoutByDir.size === 0) return routes;
-  const base = path3.join(root, "src", "routes");
+  const base = path4.join(root, "src", "routes");
   return routes.map((route) => {
     const merged = {};
-    let dir = path3.dirname(route.filePath);
-    while (dir === base || dir.startsWith(`${base}${path3.sep}`)) {
+    let dir = path4.dirname(route.filePath);
+    while (dir === base || dir.startsWith(`${base}${path4.sep}`)) {
       const meta = layoutByDir.get(dir);
       if (meta) {
         for (const field of INHERITED_METADATA_FIELDS) {
@@ -718,7 +2027,7 @@ function mergeLayoutMetadata(routes, framework, root) {
         }
       }
       if (dir === base) break;
-      dir = path3.dirname(dir);
+      dir = path4.dirname(dir);
     }
     if (Object.keys(merged).length === 0) return route;
     for (const field of INHERITED_METADATA_FIELDS) {
@@ -728,16 +2037,16 @@ function mergeLayoutMetadata(routes, framework, root) {
   });
 }
 function crawlFiles(root) {
-  const roots = [path3.join(root, "public"), path3.join(root, "static"), root];
-  const sitemap = roots.map((dir) => path3.join(dir, "sitemap.xml")).find(fs3.existsSync);
-  const robots = roots.map((dir) => path3.join(dir, "robots.txt")).find(fs3.existsSync);
-  const sitemapContent = sitemap ? fs3.readFileSync(sitemap, "utf8") : "";
+  const roots = [path4.join(root, "public"), path4.join(root, "static"), root];
+  const sitemap = roots.map((dir) => path4.join(dir, "sitemap.xml")).find(fs4.existsSync);
+  const robots = roots.map((dir) => path4.join(dir, "robots.txt")).find(fs4.existsSync);
+  const sitemapContent = sitemap ? fs4.readFileSync(sitemap, "utf8") : "";
   return {
     sitemapFound: Boolean(sitemap),
     sitemapUrls: [...sitemapContent.matchAll(/<loc>([^<]+)<\/loc>/gi)].map((m) => m[1].trim()),
     sitemapMalformed: Boolean(sitemap && (!/<urlset\b/i.test(sitemapContent) || !/<loc>[^<]+<\/loc>/i.test(sitemapContent))),
     robotsFound: Boolean(robots),
-    robotsContent: robots ? fs3.readFileSync(robots, "utf8") : ""
+    robotsContent: robots ? fs4.readFileSync(robots, "utf8") : ""
   };
 }
 var FrameworkAdapter = class {
@@ -750,11 +2059,11 @@ var FrameworkAdapter = class {
     if (deps["@remix-run/react"] || deps["@remix-run/node"]) return "remix";
     if (deps.vite) return "vite";
     if (await NextJsAdapter.detect(root)) return "nextjs";
-    if (fs3.existsSync(path3.join(root, "nuxt.config.ts")) || fs3.existsSync(path3.join(root, "nuxt.config.js"))) return "nuxt";
-    if (fs3.existsSync(path3.join(root, "svelte.config.js")) && fs3.existsSync(path3.join(root, "src", "routes"))) {
+    if (fs4.existsSync(path4.join(root, "nuxt.config.ts")) || fs4.existsSync(path4.join(root, "nuxt.config.js"))) return "nuxt";
+    if (fs4.existsSync(path4.join(root, "svelte.config.js")) && fs4.existsSync(path4.join(root, "src", "routes"))) {
       return "sveltekit";
     }
-    if (fs3.existsSync(path3.join(root, "index.html"))) return "static";
+    if (fs4.existsSync(path4.join(root, "index.html"))) return "static";
     return null;
   }
   static async scan(root) {
@@ -790,8 +2099,12 @@ var metadataTitleRule = {
     const findings = [];
     const titleMap = /* @__PURE__ */ new Map();
     for (const route of context.routes) {
+      if (route.isRedirect) continue;
       const title = route.metadata.title;
+      const dynamic = route.metadata.dynamicMetadata === true;
+      const robots = (route.metadata.robots || "").toLowerCase();
       if (!title || title.trim() === "") {
+        if (route.metadata.titleDeclared || dynamic) continue;
         findings.push({
           id: `title-missing-${route.route}`,
           rule: "metadata-title",
@@ -806,9 +2119,13 @@ var metadataTitleRule = {
         continue;
       }
       const trimmed = title.trim();
-      const existing = titleMap.get(trimmed) || [];
-      existing.push(route.route);
-      titleMap.set(trimmed, existing);
+      const indexable = !robots.includes("noindex");
+      if (route.metadata.titleDeclared && !dynamic && indexable) {
+        const existing = titleMap.get(trimmed) || [];
+        existing.push(route.route);
+        titleMap.set(trimmed, existing);
+      }
+      if (dynamic) continue;
       if (trimmed.length < 10) {
         findings.push({
           id: `title-short-${route.route}`,
@@ -864,8 +2181,12 @@ var metadataDescriptionRule = {
     const findings = [];
     const descMap = /* @__PURE__ */ new Map();
     for (const route of context.routes) {
+      if (route.isRedirect) continue;
       const desc = route.metadata.description;
+      const dynamic = route.metadata.dynamicMetadata === true;
+      const robots = (route.metadata.robots || "").toLowerCase();
       if (!desc || desc.trim() === "") {
+        if (route.metadata.descriptionDeclared || dynamic) continue;
         findings.push({
           id: `desc-missing-${route.route}`,
           rule: "metadata-description",
@@ -880,9 +2201,13 @@ var metadataDescriptionRule = {
         continue;
       }
       const trimmed = desc.trim();
-      const existing = descMap.get(trimmed) || [];
-      existing.push(route.route);
-      descMap.set(trimmed, existing);
+      const indexable = !robots.includes("noindex");
+      if (route.metadata.descriptionDeclared && !dynamic && indexable) {
+        const existing = descMap.get(trimmed) || [];
+        existing.push(route.route);
+        descMap.set(trimmed, existing);
+      }
+      if (dynamic) continue;
       if (trimmed.length < 50) {
         findings.push({
           id: `desc-short-${route.route}`,
@@ -956,8 +2281,12 @@ var canonicalRule = {
       }
     }
     for (const route of context.routes) {
+      if (route.isRedirect) continue;
+      if ((route.metadata.robots || "").toLowerCase().includes("noindex")) continue;
+      if (route.metadata.dynamicMetadata) continue;
       const canonical = route.metadata.canonical;
       if (!canonical || canonical.trim() === "") {
+        if (route.metadata.canonicalDeclared) continue;
         findings.push({
           id: `canonical-missing-${route.route}`,
           rule: "canonical",
@@ -1031,6 +2360,20 @@ var canonicalRule = {
           }
         }
       } catch {
+        const looksLikePath = canonical.startsWith("/");
+        if (looksLikePath) {
+          findings.push({
+            id: `canonical-relative-no-base-${route.route}`,
+            rule: "canonical",
+            severity: "warning",
+            category: "technical",
+            message: `Canonical URL "${canonical}" on route "${route.route}" is relative and no siteUrl/metadataBase was found to resolve it.`,
+            file: route.filePath,
+            route: route.route,
+            fixable: false
+          });
+          continue;
+        }
         findings.push({
           id: `canonical-malformed-${route.route}`,
           rule: "canonical",
@@ -1069,6 +2412,7 @@ var headingsRule = {
   analyze(context) {
     const findings = [];
     for (const route of context.routes) {
+      if (route.isRedirect) continue;
       const headings = route.headings;
       const h1s = headings.filter((h) => h.level === 1);
       if (h1s.length === 0) {
@@ -1083,19 +2427,22 @@ var headingsRule = {
           fixable: false,
           explanation: "Every page should have exactly one <h1> element defining its primary topic for search engines and accessibility."
         });
-      } else if (h1s.length > 1) {
-        findings.push({
-          id: `heading-multiple-h1-${route.route}`,
-          rule: "headings",
-          severity: "warning",
-          category: "content",
-          message: `Found ${h1s.length} <h1> tags on route "${route.route}". Best practice is a single prominent <h1>.`,
-          file: route.filePath,
-          line: h1s[1].line,
-          route: route.route,
-          fixable: false,
-          explanation: "Multiple <h1> tags can dilute topical hierarchy and confuse screen readers."
-        });
+      } else {
+        const effectiveCount = route.maxConcurrentH1 !== void 0 ? Math.max(route.maxConcurrentH1, h1s.length > 0 ? 1 : 0) : h1s.length;
+        if (effectiveCount > 1) {
+          findings.push({
+            id: `heading-multiple-h1-${route.route}`,
+            rule: "headings",
+            severity: "warning",
+            category: "content",
+            message: `Found ${effectiveCount} <h1> tags on route "${route.route}". Best practice is a single prominent <h1>.`,
+            file: route.filePath,
+            line: h1s[1].line,
+            route: route.route,
+            fixable: false,
+            explanation: "Multiple <h1> tags can dilute topical hierarchy and confuse screen readers."
+          });
+        }
       }
       let prevLevel = 1;
       for (const h of headings) {
@@ -1157,7 +2504,9 @@ var imagesRule = {
             // Never invent alt descriptions without AI
             explanation: "Missing alt attributes harm accessibility and prevent images from ranking in Google Image Search."
           });
-        } else if (img.alt.trim() === "" && !img.src.includes("icon") && !img.src.includes("decorative")) {
+        } else if (img.alt.trim() === "" && !img.src.includes("icon") && !img.src.includes("decorative") && // A runtime/dynamic src (e.g. favicon from data) cannot be judged;
+        // empty alt for it is commonly the intended decorative usage.
+        !img.src.includes("unknown-image")) {
           findings.push({
             id: `img-empty-alt-${route.route}-${img.src}`,
             rule: "images",
@@ -1177,6 +2526,44 @@ var imagesRule = {
   }
 };
 
+// ../core/src/route-match.ts
+function segmentsOf(route) {
+  return route.split("/").filter((segment) => segment !== "");
+}
+function normalizeHref(href) {
+  const clean = href.split("?")[0].split("#")[0];
+  const withoutSlash = clean.length > 1 && clean.endsWith("/") ? clean.slice(0, -1) : clean;
+  return withoutSlash === "" ? "/" : withoutSlash;
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...") || segment.startsWith("[[...");
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") && segment.endsWith("]") || isCatchAllSegment(segment);
+}
+function routePatternMatches(pattern, href) {
+  const patSegs = segmentsOf(pattern);
+  const hrefSegs = segmentsOf(href);
+  let hi = 0;
+  for (let pi = 0; pi < patSegs.length; pi += 1) {
+    const seg = patSegs[pi];
+    if (seg.startsWith("[[...") && seg.endsWith("]")) {
+      return true;
+    }
+    if (seg.startsWith("[...") && seg.endsWith("]")) {
+      return hi < hrefSegs.length;
+    }
+    if (hi >= hrefSegs.length) return false;
+    if (isDynamicSegment(seg)) {
+      hi += 1;
+      continue;
+    }
+    if (seg !== hrefSegs[hi]) return false;
+    hi += 1;
+  }
+  return hi === hrefSegs.length;
+}
+
 // ../core/src/rules/links.ts
 var linksRule = {
   id: "links",
@@ -1184,11 +2571,29 @@ var linksRule = {
   category: "links",
   analyze(context) {
     const findings = [];
-    const validRoutes = new Set(context.routes.map((r) => r.route));
     const normalizeRoute2 = (r) => r.endsWith("/") && r.length > 1 ? r.slice(0, -1) : r;
-    const normalizedValidRoutes = new Set([...validRoutes].map(normalizeRoute2));
+    const validRoutes = new Set(context.routes.map((r) => normalizeRoute2(r.route)));
     const redirects = new Map((context.redirects || []).map((redirect) => [normalizeRoute2(redirect.source), redirect.destination]));
+    const dynamicRoutes = context.routes.filter((r) => r.hasDynamicSegments);
+    const dynamicByPattern = new Map(dynamicRoutes.map((r) => [normalizeRoute2(r.route), r]));
+    const isDynamicReachable = (cleanHref) => {
+      for (const [pattern, routeNode2] of dynamicByPattern) {
+        if (routePatternMatches(pattern, cleanHref)) {
+          if (routeNode2.dynamicParams !== false) return { reachable: true, route: routeNode2 };
+          const candidates = new Set(routeNode2.generatedParams || []);
+          const targetSegment = cleanHref.split("/").pop() || "";
+          if (targetSegment !== "" && candidates.has(targetSegment)) return { reachable: true, route: routeNode2 };
+          return {
+            reachable: false,
+            route: routeNode2,
+            reason: `route "${pattern}" only renders its generateStaticParams output and "${targetSegment}" could not be verified`
+          };
+        }
+      }
+      return { reachable: false };
+    };
     for (const route of context.routes) {
+      if (route.isRedirect) continue;
       for (const link of route.links) {
         if (!link.isInternal) continue;
         const href = link.href.trim();
@@ -1207,7 +2612,7 @@ var linksRule = {
           });
           continue;
         }
-        const cleanHref = normalizeRoute2(href.split("?")[0].split("#")[0]);
+        const cleanHref = normalizeHref(href);
         if (cleanHref.startsWith("/")) {
           const redirectTarget = redirects.get(cleanHref);
           if (redirectTarget) {
@@ -1223,10 +2628,28 @@ var linksRule = {
               fixable: false,
               explanation: "Link directly to the final internal route to avoid unnecessary crawl hops."
             });
+            continue;
           }
-          if (!normalizedValidRoutes.has(cleanHref) && !redirectTarget) {
+          if (!validRoutes.has(cleanHref)) {
+            const dynamic = isDynamicReachable(cleanHref);
+            if (dynamic.reachable) continue;
+            if (dynamic.route) {
+              findings.push({
+                id: `link-unverifiable-dynamic-${route.route}-${cleanHref}`,
+                rule: "links",
+                severity: "warning",
+                category: "links",
+                message: `Internal link "${href}" on "${route.route}" targets dynamic ${dynamic.route.route}, but ${dynamic.reason}.`,
+                file: route.filePath,
+                line: link.line,
+                route: route.route,
+                fixable: false,
+                explanation: "The target route renders only its generateStaticParams output; this link cannot be statically verified as reachable."
+              });
+              continue;
+            }
             let isTypoFixable = false;
-            for (const valid of normalizedValidRoutes) {
+            for (const valid of validRoutes) {
               if (valid.toLowerCase() === cleanHref.toLowerCase()) {
                 isTypoFixable = true;
                 break;
@@ -1324,11 +2747,13 @@ var crawlabilityRule = {
         });
       }
       const validRoutes = new Set(context.routes.map((r) => r.route));
+      const dynamicPatterns = context.routes.filter((r) => r.hasDynamicSegments).map((r) => r.route);
       for (const url of context.sitemapUrls) {
         try {
           const pathname = url.startsWith("http") ? new URL(url).pathname : url;
-          const clean = pathname.endsWith("/") && pathname.length > 1 ? pathname.slice(0, -1) : pathname;
-          if (!validRoutes.has(clean) && clean !== "") {
+          const clean = normalizeHref(pathname);
+          const isKnown = validRoutes.has(clean) || dynamicPatterns.some((pattern) => routePatternMatches(pattern, clean));
+          if (!isKnown && clean !== "" && clean !== "/") {
             findings.push({
               id: `sitemap-orphan-url-${clean}`,
               rule: "crawlability",
@@ -1637,7 +3062,7 @@ function buildLinkGraph(routes, redirects = []) {
     outgoingCount[node] = 0;
     adjacencyList[node] = [];
   }
-  const normalize = (path9) => path9.endsWith("/") && path9.length > 1 ? path9.slice(0, -1) : path9;
+  const normalize = (path10) => path10.endsWith("/") && path10.length > 1 ? path10.slice(0, -1) : path10;
   const redirectMap = new Map(redirects.map((redirect) => [normalize(redirect.source), normalize(redirect.destination)]));
   for (const route of routes) {
     const source = route.route;
@@ -1903,8 +3328,8 @@ function detectContentOpportunities(routes, providedKeywords = {}) {
 }
 
 // ../core/src/fixer.ts
-import path4 from "node:path";
-import fs4 from "node:fs";
+import path5 from "node:path";
+import fs5 from "node:fs";
 function createUnifiedDiff(filename, oldText, newText) {
   const oldLines = oldText ? oldText.split("\n") : [];
   const newLines = newText ? newText.split("\n") : [];
@@ -1958,7 +3383,7 @@ function generateRevertSafeFix(options) {
             filePath,
             originalContent: headContent,
             newContent: updated,
-            diff: createUnifiedDiff(path4.relative(projectRoot, filePath), headContent, updated),
+            diff: createUnifiedDiff(path5.relative(projectRoot, filePath), headContent, updated),
             description: `Restored canonical value "${canonicalVal}" from BASE revision.`
           };
         }
@@ -1973,7 +3398,7 @@ function generateRevertSafeFix(options) {
           filePath,
           originalContent: headContent,
           newContent: updated,
-          diff: createUnifiedDiff(path4.relative(projectRoot, filePath), headContent, updated),
+          diff: createUnifiedDiff(path5.relative(projectRoot, filePath), headContent, updated),
           description: "Restored indexable robots directive present in BASE revision."
         };
       }
@@ -2072,19 +3497,19 @@ ${content}`;
 }
 function assetLayout(projectRoot, framework, isAppRouter) {
   if (framework === "nextjs" && isAppRouter) {
-    const appDirectory = fs4.existsSync(path4.join(projectRoot, "app")) ? path4.join(projectRoot, "app") : path4.join(projectRoot, "src", "app");
+    const appDirectory = fs5.existsSync(path5.join(projectRoot, "app")) ? path5.join(projectRoot, "app") : path5.join(projectRoot, "src", "app");
     return { kind: "app-router", directory: appDirectory };
   }
   let directory;
   switch (framework) {
     case "sveltekit":
-      directory = path4.join(projectRoot, "static");
+      directory = path5.join(projectRoot, "static");
       break;
     case "static":
       directory = projectRoot;
       break;
     default:
-      directory = path4.join(projectRoot, "public");
+      directory = path5.join(projectRoot, "public");
   }
   return { kind: "file", directory };
 }
@@ -2115,21 +3540,21 @@ async function applySafeFixes(options) {
   const fixedFindingIds = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
   const safeFile = (candidate) => {
-    const root = path4.resolve(projectRoot);
-    const resolved = path4.resolve(candidate);
-    return resolved === root || resolved.startsWith(`${root}${path4.sep}`) ? resolved : null;
+    const root = path5.resolve(projectRoot);
+    const resolved = path5.resolve(candidate);
+    return resolved === root || resolved.startsWith(`${root}${path5.sep}`) ? resolved : null;
   };
   const readCurrent = (candidate) => {
     if (virtualFiles.has(candidate)) return virtualFiles.get(candidate);
-    return fs4.existsSync(candidate) ? fs4.readFileSync(candidate, "utf8") : "";
+    return fs5.existsSync(candidate) ? fs5.readFileSync(candidate, "utf8") : "";
   };
   const recordChange = (change, findingId) => {
     appliedChanges.push(change);
     fixedFindingIds.add(findingId);
     virtualFiles.set(change.filePath, change.newContent);
     if (!dryRun) {
-      fs4.mkdirSync(path4.dirname(change.filePath), { recursive: true });
-      fs4.writeFileSync(change.filePath, change.newContent, "utf8");
+      fs5.mkdirSync(path5.dirname(change.filePath), { recursive: true });
+      fs5.writeFileSync(change.filePath, change.newContent, "utf8");
     }
   };
   const layout = assetLayout(projectRoot, framework, isAppRouter);
@@ -2140,7 +3565,7 @@ async function applySafeFixes(options) {
     for (const f of revertSafeFindings) {
       const targetFile = f.file ? safeFile(f.file) : null;
       if (!targetFile) continue;
-      const relPath = path4.relative(projectRoot, targetFile).replace(/\\/g, "/");
+      const relPath = path5.relative(projectRoot, targetFile).replace(/\\/g, "/");
       const baseContent = options.baseFiles.get(relPath) || options.baseFiles.get(targetFile);
       if (!baseContent) continue;
       const headContent = readCurrent(targetFile);
@@ -2159,9 +3584,9 @@ async function applySafeFixes(options) {
   const robotsFinding = findings.find((f) => f.rule === "crawlability" && f.id === "robots-missing");
   if (robotsFinding) {
     if (layout.kind === "app-router") {
-      const robotsFilePath = path4.join(layout.directory, "robots.ts");
-      const relativePath = path4.relative(projectRoot, robotsFilePath);
-      const oldContent = fs4.existsSync(robotsFilePath) ? fs4.readFileSync(robotsFilePath, "utf8") : "";
+      const robotsFilePath = path5.join(layout.directory, "robots.ts");
+      const relativePath = path5.relative(projectRoot, robotsFilePath);
+      const oldContent = fs5.existsSync(robotsFilePath) ? fs5.readFileSync(robotsFilePath, "utf8") : "";
       const sitemapLine = siteUrl ? `
     sitemap: '${siteUrl}/sitemap.xml',` : "";
       const newContent = `import { MetadataRoute } from 'next';
@@ -2185,9 +3610,9 @@ export default function robots(): MetadataRoute.Robots {
         description: "Generated app/robots.ts with standard crawler rules and sitemap reference."
       }, robotsFinding.id);
     } else {
-      const robotsFilePath = path4.join(layout.directory, "robots.txt");
-      const relativePath = path4.relative(projectRoot, robotsFilePath);
-      const oldContent = fs4.existsSync(robotsFilePath) ? fs4.readFileSync(robotsFilePath, "utf8") : "";
+      const robotsFilePath = path5.join(layout.directory, "robots.txt");
+      const relativePath = path5.relative(projectRoot, robotsFilePath);
+      const oldContent = fs5.existsSync(robotsFilePath) ? fs5.readFileSync(robotsFilePath, "utf8") : "";
       const newContent = ROBOTS_TXT(siteUrl);
       recordChange({
         filePath: robotsFilePath,
@@ -2203,9 +3628,9 @@ export default function robots(): MetadataRoute.Robots {
   );
   if (sitemapFinding && siteUrl) {
     if (layout.kind === "app-router") {
-      const sitemapFilePath = path4.join(layout.directory, "sitemap.ts");
-      const relativePath = path4.relative(projectRoot, sitemapFilePath);
-      const oldContent = fs4.existsSync(sitemapFilePath) ? fs4.readFileSync(sitemapFilePath, "utf8") : "";
+      const sitemapFilePath = path5.join(layout.directory, "sitemap.ts");
+      const relativePath = path5.relative(projectRoot, sitemapFilePath);
+      const oldContent = fs5.existsSync(sitemapFilePath) ? fs5.readFileSync(sitemapFilePath, "utf8") : "";
       const routeEntries = validRoutes.map(
         (r) => `    {
       url: '${siteUrl}${r === "/" ? "" : r}',
@@ -2230,9 +3655,9 @@ ${routeEntries}
         description: `Generated app/sitemap.ts containing ${validRoutes.length} discovered routes.`
       }, sitemapFinding.id);
     } else {
-      const sitemapFilePath = path4.join(layout.directory, "sitemap.xml");
-      const relativePath = path4.relative(projectRoot, sitemapFilePath);
-      const oldContent = fs4.existsSync(sitemapFilePath) ? fs4.readFileSync(sitemapFilePath, "utf8") : "";
+      const sitemapFilePath = path5.join(layout.directory, "sitemap.xml");
+      const relativePath = path5.relative(projectRoot, sitemapFilePath);
+      const oldContent = fs5.existsSync(sitemapFilePath) ? fs5.readFileSync(sitemapFilePath, "utf8") : "";
       const xmlEntries = validRoutes.map(
         (r) => `  <url>
     <loc>${siteUrl}${r === "/" ? "" : r}</loc>
@@ -2258,7 +3683,7 @@ ${xmlEntries}
     const canonicalFindings = findings.filter((f) => f.rule === "canonical" && f.fixable && f.file);
     for (const finding of canonicalFindings) {
       const findingFile = finding.file ? safeFile(finding.file) : null;
-      if (!findingFile || !fs4.existsSync(findingFile)) continue;
+      if (!findingFile || !fs5.existsSync(findingFile)) continue;
       const fileContent = readCurrent(findingFile);
       const route = finding.route || "/";
       const canonicalUrl = `${siteUrl}${route === "/" ? "" : route}`;
@@ -2268,8 +3693,8 @@ ${xmlEntries}
           filePath: findingFile,
           originalContent: fileContent,
           newContent: updatedContent,
-          diff: createUnifiedDiff(path4.relative(projectRoot, findingFile), fileContent, updatedContent),
-          description: `Added canonical "${canonicalUrl}" declaration to ${path4.basename(findingFile)}.`
+          diff: createUnifiedDiff(path5.relative(projectRoot, findingFile), fileContent, updatedContent),
+          description: `Added canonical "${canonicalUrl}" declaration to ${path5.basename(findingFile)}.`
         }, finding.id);
       }
     }
@@ -2277,7 +3702,7 @@ ${xmlEntries}
   const fixableLinkFindings = findings.filter((f) => f.rule === "links" && f.fixable && f.file);
   for (const lf of fixableLinkFindings) {
     const linkFile = lf.file ? safeFile(lf.file) : null;
-    if (!linkFile || !fs4.existsSync(linkFile)) continue;
+    if (!linkFile || !fs5.existsSync(linkFile)) continue;
     const fileContent = readCurrent(linkFile);
     const match = lf.message.match(/nonexistent route "([^"]+)"/);
     if (match) {
@@ -2296,7 +3721,7 @@ ${xmlEntries}
             filePath: linkFile,
             originalContent: fileContent,
             newContent: updatedContent,
-            diff: createUnifiedDiff(path4.relative(projectRoot, linkFile), fileContent, updatedContent),
+            diff: createUnifiedDiff(path5.relative(projectRoot, linkFile), fileContent, updatedContent),
             description: `Fixed casing of internal link: "${brokenHref}" -> "${normalizedTarget}".`
           }, lf.id);
         }
@@ -2446,7 +3871,7 @@ function runSEOAudit(options) {
     recommendations,
     opportunities,
     timestamp,
-    engineVersion: "0.2.0"
+    engineVersion: "0.3.1"
   };
 }
 
@@ -2524,7 +3949,7 @@ function evaluateQualityGate(input) {
 }
 
 // ../core/src/diff-engine.ts
-import path5 from "node:path";
+import path6 from "node:path";
 
 // ../core/src/contracts.ts
 function matchesRoutePattern(route, pattern) {
@@ -3012,19 +4437,19 @@ function consolidateRegressionsByRootCause(rawNewFindings, baseAudit, headAudit,
     const layoutPath = mut.nodeId.replace(/^layout:/, "");
     const downstream = traceDownstreamRoutes(headSEOGraph, layoutPath);
     if (downstream.length === 0) continue;
-    const prop = mut.property;
+    const prop2 = mut.property;
     const matching = rawNewFindings.filter((f) => {
       if (handledIds.has(f.id)) return false;
       const routeMatch = f.route && downstream.includes(f.route);
-      const propMatch = prop === "canonical" ? f.rule.includes("canonical") : f.rule.includes("robots") || f.message.includes("noindex");
+      const propMatch = prop2 === "canonical" ? f.rule.includes("canonical") : f.rule.includes("robots") || f.message.includes("noindex");
       return routeMatch && propMatch;
     });
     if (matching.length > 0) {
       for (const m of matching) handledIds.add(m.id);
-      const isCanonical = prop === "canonical";
-      const baseName = path5.basename(layoutPath);
+      const isCanonical = prop2 === "canonical";
+      const baseName = path6.basename(layoutPath);
       consolidated.push({
-        id: `regression-${baseName}-${prop}`,
+        id: `regression-${baseName}-${prop2}`,
         rule: isCanonical ? "metadata/canonical-regression" : "crawlability/robots-regression",
         severity: "error",
         category: isCanonical ? "metadata" : "technical",
@@ -3057,7 +4482,7 @@ function consolidateRegressionsByRootCause(rawNewFindings, baseAudit, headAudit,
           sampleRoutes: downstream.slice(0, 3),
           confidence: "STRUCTURAL",
           revertSafeValue: mut.oldValue ? String(mut.oldValue) : void 0,
-          fixRecommendation: `Restore previous ${prop} declaration from BASE revision in ${baseName}.`
+          fixRecommendation: `Restore previous ${prop2} declaration from BASE revision in ${baseName}.`
         }
       });
     }
@@ -3087,7 +4512,7 @@ function consolidateRegressionsByRootCause(rawNewFindings, baseAudit, headAudit,
           (n) => n.type === "layout" && (n.path?.includes(dir.replace("/", "")) || n.id.includes(dir.replace("/", "")))
         );
         const inferredLayoutFile = layoutNode?.path || `app${dir}/layout.tsx`;
-        const baseName = path5.basename(inferredLayoutFile);
+        const baseName = path6.basename(inferredLayoutFile);
         const affected = dirFindings.map((f) => f.route).sort();
         for (const df of dirFindings) handledIds.add(df.id);
         consolidated.push({
@@ -3807,8 +5232,8 @@ var SessionKeyStore = class {
 var sessionKeyStore = new SessionKeyStore();
 
 // ../ai/src/semantic-resolver.ts
-import fs5 from "node:fs";
-import path6 from "node:path";
+import fs6 from "node:fs";
+import path7 from "node:path";
 var METADATA_KEYS = ["canonical", "robots", "title", "description"];
 function helperDefinesProperty(helperCode, property) {
   const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -3819,8 +5244,8 @@ async function resolveSemanticHelpers(options) {
   if (!aiProvider) return [];
   const results = [];
   for (const route of routes) {
-    if (!route.filePath || !fs5.existsSync(route.filePath)) continue;
-    const content = fs5.readFileSync(route.filePath, "utf8");
+    if (!route.filePath || !fs6.existsSync(route.filePath)) continue;
+    const content = fs6.readFileSync(route.filePath, "utf8");
     const helperMatch = content.match(
       /export\s+const\s+metadata\s*=\s*([A-Za-z0-9_]+)\s*\(([\s\S]*?)\)/
     );
@@ -3835,16 +5260,16 @@ async function resolveSemanticHelpers(options) {
     if (importMatch) {
       const importPath = importMatch[1];
       const candidates = [
-        path6.resolve(path6.dirname(route.filePath), `${importPath}.ts`),
-        path6.resolve(path6.dirname(route.filePath), `${importPath}.tsx`),
-        path6.resolve(path6.dirname(route.filePath), `${importPath}/index.ts`),
-        path6.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.ts`),
-        path6.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.tsx`)
+        path7.resolve(path7.dirname(route.filePath), `${importPath}.ts`),
+        path7.resolve(path7.dirname(route.filePath), `${importPath}.tsx`),
+        path7.resolve(path7.dirname(route.filePath), `${importPath}/index.ts`),
+        path7.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.ts`),
+        path7.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.tsx`)
       ];
       for (const cand of candidates) {
-        if (fs5.existsSync(cand)) {
+        if (fs6.existsSync(cand)) {
           helperFilePath = cand;
-          helperCode = fs5.readFileSync(cand, "utf8");
+          helperCode = fs6.readFileSync(cand, "utf8");
           break;
         }
       }
@@ -3869,7 +5294,7 @@ async function resolveSemanticHelpers(options) {
       if (hasMeaningfulProps) {
         const verifiedProperties = helperCode ? METADATA_KEYS.filter((property) => resolution.maps[property] && helperDefinesProperty(helperCode, property)) : [];
         const confidence = verifiedProperties.length > 0 ? "AI_VERIFIED" : "AI_ASSISTED";
-        const cleanHelperPath = helperFilePath ? path6.relative(projectRoot, helperFilePath).replace(/\\/g, "/") : helperName;
+        const cleanHelperPath = helperFilePath ? path7.relative(projectRoot, helperFilePath).replace(/\\/g, "/") : helperName;
         const resolvedMeta = {};
         if (verifiedProperties.includes("canonical") && !route.metadata?.canonical) {
           resolvedMeta.canonical = resolution.maps.canonical;
@@ -3877,7 +5302,7 @@ async function resolveSemanticHelpers(options) {
         if (verifiedProperties.includes("robots") && !route.metadata?.robots) {
           resolvedMeta.robots = resolution.maps.robots;
         }
-        const proofId = `proof-seo-${path6.basename(route.filePath)}-${helperName}`;
+        const proofId = `proof-seo-${path7.basename(route.filePath)}-${helperName}`;
         const evidenceItems = [
           {
             id: `ev-callsite-${helperName}`,
@@ -3898,23 +5323,23 @@ async function resolveSemanticHelpers(options) {
         }
         const verifiedClaims = [];
         const rejectedClaims = [];
-        for (const [prop, val] of Object.entries(resolution.maps)) {
+        for (const [prop2, val] of Object.entries(resolution.maps)) {
           if (val) {
-            if (helperVerified && verifiedProperties.includes(prop)) {
+            if (helperVerified && verifiedProperties.includes(prop2)) {
               verifiedClaims.push({
-                id: `claim-${prop}-${helperName}`,
+                id: `claim-${prop2}-${helperName}`,
                 subject: route.route,
-                predicate: `has${prop.charAt(0).toUpperCase() + prop.slice(1)}`,
+                predicate: `has${prop2.charAt(0).toUpperCase() + prop2.slice(1)}`,
                 observedValue: val,
                 evidenceRefs: evidenceItems.map((e) => e.id),
                 source: { file: cleanHelperPath, route: route.route }
               });
             } else {
               rejectedClaims.push({
-                id: `claim-${prop}-${helperName}`,
+                id: `claim-${prop2}-${helperName}`,
                 subject: route.route,
-                predicate: `has${prop.charAt(0).toUpperCase() + prop.slice(1)}`,
-                reason: helperVerified ? `Helper source does not deterministically define metadata property "${prop}".` : "Helper source code could not be verified on filesystem."
+                predicate: `has${prop2.charAt(0).toUpperCase() + prop2.slice(1)}`,
+                reason: helperVerified ? `Helper source does not deterministically define metadata property "${prop2}".` : "Helper source code could not be verified on filesystem."
               });
             }
           }
@@ -3942,7 +5367,7 @@ async function resolveSemanticHelpers(options) {
             discoveredBy: "AI",
             verifiedBy: verifiedProperties.length > 0 ? "DETERMINISTIC_VERIFIER" : void 0,
             evidence: [
-              `Call site: ${path6.basename(route.filePath)}`,
+              `Call site: ${path7.basename(route.filePath)}`,
               helperVerified ? `Helper definition: ${cleanHelperPath}` : `Inferred signature from ${helperName}`,
               ...resolution.evidenceChain || []
             ]
@@ -3965,7 +5390,7 @@ async function resolveSemanticHelpers(options) {
 }
 
 // src/formatter.ts
-import path7 from "node:path";
+import path8 from "node:path";
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -4020,7 +5445,7 @@ ${colors.dim}${"\u2501".repeat(45)}${colors.reset}
       console.log(`${colors.dim}${"\u2501".repeat(45)}${colors.reset}
 `);
       const rawFile = f.rootCause?.file || f.sourceFile || f.file || "";
-      const relFile = rawFile ? path7.relative(projectRoot, rawFile).replace(/\\/g, "/") : "";
+      const relFile = rawFile ? path8.relative(projectRoot, rawFile).replace(/\\/g, "/") : "";
       const lineSuffix = f.rootCause?.line || f.sourceLine || f.line ? `:${f.rootCause?.line || f.sourceLine || f.line}` : "";
       if (f.rootCause) {
         console.log(`${colors.bold}Root cause${colors.reset}`);
@@ -4041,7 +5466,7 @@ ${colors.dim}${"\u2501".repeat(45)}${colors.reset}
       }
       if (f.evidenceChain?.steps && f.evidenceChain.steps.length > 0) {
         console.log(`${colors.bold}Dependency${colors.reset}`);
-        const sourceName = path7.basename(relFile || f.evidenceChain.sourceFile);
+        const sourceName = path8.basename(relFile || f.evidenceChain.sourceFile);
         console.log(`${sourceName}`);
         for (const step of f.evidenceChain.steps) {
           const detail = step.detail ? ` ${step.detail}` : "";
@@ -4165,7 +5590,7 @@ function printAuditReport(result, projectRoot) {
     if (f.severity === "warning") icon = colors.yellow + "\u26A0" + colors.reset;
     const fixTag = f.fixable ? ` ${colors.green}[fixable]${colors.reset}` : "";
     const routeTag = f.route ? ` ${colors.cyan}(${f.route})${colors.reset}` : "";
-    const relativeFile = f.file ? path7.relative(projectRoot, f.file) : "";
+    const relativeFile = f.file ? path8.relative(projectRoot, f.file) : "";
     const fileTag = relativeFile ? `
     ${colors.dim}${relativeFile}${f.line ? `:${f.line}` : ""}${colors.reset}` : "";
     console.log(`  ${icon} ${f.message}${fixTag}${routeTag}${fileTag}`);
@@ -4261,7 +5686,7 @@ function loadLocalEnv(projectRoot) {
   const dirsToSearch = [projectRoot];
   let curr = projectRoot;
   for (let i = 0; i < 4; i++) {
-    const parent = path8.dirname(curr);
+    const parent = path9.dirname(curr);
     if (parent && parent !== curr) {
       dirsToSearch.push(parent);
       curr = parent;
@@ -4271,10 +5696,10 @@ function loadLocalEnv(projectRoot) {
   }
   for (const dir of dirsToSearch) {
     for (const envFile of [".env", ".env.local"]) {
-      const fullPath = path8.join(dir, envFile);
-      if (fs6.existsSync(fullPath)) {
+      const fullPath = path9.join(dir, envFile);
+      if (fs7.existsSync(fullPath)) {
         try {
-          const content = fs6.readFileSync(fullPath, "utf8");
+          const content = fs7.readFileSync(fullPath, "utf8");
           for (const line of content.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed || trimmed.startsWith("#")) continue;
@@ -4297,15 +5722,15 @@ function loadLocalEnv(projectRoot) {
   }
 }
 function checkSecretRisk(projectRoot) {
-  const envCandidates = fs6.readdirSync(projectRoot).filter((name) => name !== ".env.example" && (name === ".env" || name.startsWith(".env.")));
-  const gitignorePath = path8.join(projectRoot, ".gitignore");
+  const envCandidates = fs7.readdirSync(projectRoot).filter((name) => name !== ".env.example" && (name === ".env" || name.startsWith(".env.")));
+  const gitignorePath = path9.join(projectRoot, ".gitignore");
   let gitignoreContent = "";
-  if (fs6.existsSync(gitignorePath)) {
-    gitignoreContent = fs6.readFileSync(gitignorePath, "utf8");
+  if (fs7.existsSync(gitignorePath)) {
+    gitignoreContent = fs7.readFileSync(gitignorePath, "utf8");
   }
   for (const env of envCandidates) {
-    const envPath = path8.join(projectRoot, env);
-    if (fs6.existsSync(envPath)) {
+    const envPath = path9.join(projectRoot, env);
+    if (fs7.existsSync(envPath)) {
       const tracked = spawnSync("git", ["ls-files", "--error-unmatch", "--", env], {
         cwd: projectRoot,
         stdio: "ignore"
@@ -4317,11 +5742,11 @@ function checkSecretRisk(projectRoot) {
   }
 }
 async function auditGitRef(projectRoot, ref) {
-  const tmpDir = fs6.mkdtempSync(path8.join(os.tmpdir(), "crawlemon-base-"));
+  const tmpDir = fs7.mkdtempSync(path9.join(os.tmpdir(), "crawlemon-base-"));
   try {
     const gitRootRes = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: projectRoot, encoding: "utf8" });
     const gitRoot = gitRootRes.status === 0 ? gitRootRes.stdout.trim() : projectRoot;
-    const relToGitRoot = path8.relative(gitRoot, projectRoot).replace(/\\/g, "/");
+    const relToGitRoot = path9.relative(gitRoot, projectRoot).replace(/\\/g, "/");
     const archiveRef = relToGitRoot && relToGitRoot !== "." ? `${ref}:${relToGitRoot}` : ref;
     const gitArchive = spawnSync("git", ["archive", archiveRef], {
       cwd: gitRoot,
@@ -4348,7 +5773,7 @@ async function auditGitRef(projectRoot, ref) {
       isAppRouter: scanData.isAppRouter
     });
   } finally {
-    fs6.rmSync(tmpDir, { recursive: true, force: true });
+    fs7.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function runCli(args) {
@@ -4364,7 +5789,7 @@ async function runCli(args) {
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.2.0");
+    console.log("0.3.1");
     return;
   }
   checkSecretRisk(projectRoot);
@@ -4463,25 +5888,25 @@ async function runCli(args) {
       try {
         const gitRootRes = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: projectRoot, encoding: "utf8" });
         const gitRoot = gitRootRes.status === 0 ? gitRootRes.stdout.trim() : projectRoot;
-        const relToGitRoot = path8.relative(gitRoot, projectRoot).replace(/\\/g, "/");
+        const relToGitRoot = path9.relative(gitRoot, projectRoot).replace(/\\/g, "/");
         const archiveRef = relToGitRoot && relToGitRoot !== "." ? `${baseRefArg}:${relToGitRoot}` : baseRefArg;
         const gitArchive = spawnSync("git", ["archive", archiveRef], { cwd: gitRoot, maxBuffer: 64 * 1024 * 1024 });
         if (gitArchive.status === 0 && gitArchive.stdout) {
-          const tmpDir = fs6.mkdtempSync(path8.join(os.tmpdir(), "crawlemon-base-fix-"));
+          const tmpDir = fs7.mkdtempSync(path9.join(os.tmpdir(), "crawlemon-base-fix-"));
           spawnSync("tar", ["-x", "-C", tmpDir], { input: gitArchive.stdout });
           baseFiles = /* @__PURE__ */ new Map();
           const walk2 = (d) => {
-            for (const ent of fs6.readdirSync(d, { withFileTypes: true })) {
-              const full = path8.join(d, ent.name);
+            for (const ent of fs7.readdirSync(d, { withFileTypes: true })) {
+              const full = path9.join(d, ent.name);
               if (ent.isDirectory()) walk2(full);
               else if (ent.isFile()) {
-                const rel = path8.relative(tmpDir, full).replace(/\\/g, "/");
-                baseFiles.set(rel, fs6.readFileSync(full, "utf8"));
+                const rel = path9.relative(tmpDir, full).replace(/\\/g, "/");
+                baseFiles.set(rel, fs7.readFileSync(full, "utf8"));
               }
             }
           };
           walk2(tmpDir);
-          fs6.rmSync(tmpDir, { recursive: true, force: true });
+          fs7.rmSync(tmpDir, { recursive: true, force: true });
         }
       } catch {
       }