slopbrick 0.18.4 → 0.18.7

package/dist/engine/worker.js

@@ -6316,6 +6316,78 @@ function extractStateBinding(node, lineOffsets) {
     setterReferenced: false
   };
 }
+function findUnreachableStatements(ast, source, lineOffsets) {
+  const out = [];
+  function isTerminator(node) {
+    if (node.type === "ReturnStatement") return "return";
+    if (node.type === "ThrowStatement") return "throw";
+    if (node.type === "BreakStatement") return "break";
+    if (node.type === "ContinueStatement") return "continue";
+    return null;
+  }
+  function snippetFor(node, src) {
+    const span = node.span;
+    if (!span || typeof span.start !== "number" || typeof span.end !== "number") {
+      return "<unreachable>";
+    }
+    const text = src.slice(span.start, Math.min(span.end, span.start + 60));
+    return text.replace(/\s+/g, " ").trim() || "<unreachable>";
+  }
+  function lineColumn(offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      const midVal = lineOffsets[mid];
+      const loVal = lineOffsets[lo];
+      if (midVal === void 0) break;
+      if (midVal <= offset) lo = mid;
+      else hi = mid - 1;
+      void loVal;
+    }
+    const baseOffset = lineOffsets[lo] ?? 0;
+    return { line: lo + 1, column: offset - baseOffset };
+  }
+  function visitBody(body) {
+    if (!Array.isArray(body)) return;
+    let lastTerminator = null;
+    for (const stmt of body) {
+      if (!isObject(stmt)) continue;
+      if (lastTerminator && stmt.type !== "EmptyStatement") {
+        const span = stmt.span;
+        const offset = typeof span?.start === "number" ? span.start : 0;
+        const { line, column } = lineColumn(offset);
+        out.push({
+          terminator: lastTerminator,
+          line,
+          column,
+          snippet: snippetFor(stmt, source)
+        });
+      }
+      const t = isTerminator(stmt);
+      if (t) lastTerminator = t;
+    }
+  }
+  function walk3(node) {
+    if (!isObject(node)) return;
+    if (node.type === "BlockStatement") {
+      visitBody(node.stmts);
+    } else if (node.type === "Module") {
+      visitBody(node.body);
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent" || key === "span" || key === "ctxt") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const c of child) walk3(c);
+      } else {
+        walk3(child);
+      }
+    }
+  }
+  walk3(ast);
+  return out;
+}
 
 // src/engine/visitors/dispatch.ts
 function nearestComponent(vctx) {
@@ -6392,15 +6464,42 @@ function handleImportDeclaration(node, _parent, _path, vctx) {
         if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
           const local = specifier.local;
           if (isObject(local) && local.type === "Identifier" && typeof local.value === "string") {
-            importedNames.push(local.value);
+            const name = local.value;
+            importedNames.push(name);
+            vctx.facts.deadCode.bindings.push({
+              name,
+              kind: specifier.type === "ImportDefaultSpecifier" ? "import-default" : "import-namespace",
+              line,
+              column,
+              source,
+              isReferenced: false
+            });
           }
         } else if (specifier.type === "ImportSpecifier") {
           const imported = specifier.imported;
           const local = specifier.local;
           if (isObject(imported) && typeof imported.value === "string" && imported.value.length > 0) {
-            importedNames.push(imported.value);
+            const name = imported.value;
+            importedNames.push(name);
+            vctx.facts.deadCode.bindings.push({
+              name,
+              kind: "import-specifier",
+              line,
+              column,
+              source,
+              isReferenced: false
+            });
           } else if (isObject(local) && local.type === "Identifier" && typeof local.value === "string") {
-            importedNames.push(local.value);
+            const name = local.value;
+            importedNames.push(name);
+            vctx.facts.deadCode.bindings.push({
+              name,
+              kind: "import-specifier",
+              line,
+              column,
+              source,
+              isReferenced: false
+            });
           }
         }
       }
@@ -6490,6 +6589,13 @@ function isBindingSite(node, parent) {
       if (params.some((param) => containsNode(param, node))) return true;
     }
   }
+  if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") {
+    if (parent.type === "ImportSpecifier") {
+      if (parent.imported === node || parent.local === node) return true;
+    } else {
+      if (parent.local === node) return true;
+    }
+  }
   return false;
 }
 function isNonComputedMemberProperty(node, parent) {
@@ -6556,6 +6662,9 @@ function handleIdentifier(node, parent, path, vctx) {
   if (typeof node.value === "string" && !isBindingSite(node, parent) && !isNonComputedMemberProperty(node, parent)) {
     markStateReference(node.value, vctx);
     trackPropUsage(node, parent, path, vctx);
+    vctx.facts.referencedNames.add(node.value);
+    const top = vctx.ctx.stack[vctx.ctx.stack.length - 1];
+    if (top) top.references.add(node.value);
   }
   return false;
 }
@@ -6696,6 +6805,20 @@ function handleVariableDeclarator(node, _parent, path, vctx) {
       frame.bindings.add(bindingName);
     }
   }
+  if (bindingNames.length > 0) {
+    const parent = node.parent;
+    const kind = isObject(parent) && parent.type === "VariableDeclaration" ? String(parent.kind ?? "var") : "var";
+    const { line, column } = positionFrom(id, vctx.lineOffsets);
+    for (const bindingName of bindingNames) {
+      vctx.facts.deadCode.bindings.push({
+        name: bindingName,
+        kind,
+        line,
+        column,
+        isReferenced: false
+      });
+    }
+  }
   if (isUseStateDeclarator(node)) {
     const binding = extractStateBinding(node, vctx.lineOffsets);
     if (binding) {
@@ -6715,6 +6838,36 @@ function handleVariableDeclarator(node, _parent, path, vctx) {
   }
   return true;
 }
+function handleIfStatement(node, _parent, _path, vctx) {
+  if (!isObject(node)) return false;
+  const test = node.test;
+  if (!isObject(test)) return false;
+  if (test.type === "BooleanLiteral" && typeof test.value === "boolean") {
+    const { line, column } = positionFrom(test, vctx.lineOffsets);
+    vctx.facts.deadCode.constantConditions.push({
+      kind: test.value ? "if-true" : "if-false",
+      condition: String(test.value),
+      line,
+      column
+    });
+  }
+  return false;
+}
+function handleWhileStatement(node, _parent, _path, vctx) {
+  if (!isObject(node)) return false;
+  const test = node.test;
+  if (!isObject(test)) return false;
+  if (test.type === "BooleanLiteral" && typeof test.value === "boolean") {
+    const { line, column } = positionFrom(test, vctx.lineOffsets);
+    vctx.facts.deadCode.constantConditions.push({
+      kind: test.value ? "while-true" : "while-false",
+      condition: String(test.value),
+      line,
+      column
+    });
+  }
+  return false;
+}
 var HANDLERS = {
   ExpressionStatement: handleExpressionStatement,
   ImportDeclaration: handleImportDeclaration,
@@ -6724,7 +6877,9 @@ var HANDLERS = {
   MemberExpression: handleMemberExpression,
   JSXAttribute: handleJSXAttribute,
   JSXOpeningElement: handleJSXOpeningElement,
-  VariableDeclarator: handleVariableDeclarator
+  VariableDeclarator: handleVariableDeclarator,
+  IfStatement: handleIfStatement,
+  WhileStatement: handleWhileStatement
 };
 function dispatchNode(node, parent, path, vctx) {
   if (!isObject(node)) return false;
@@ -6889,6 +7044,17 @@ function buildV2Facts(facts, source, ext, framework, config, templateClassNames
     },
     logic: buildLogicBlock(facts),
     designTokens: scanDesignTokens(facts.staticClassNames),
+    //  dead-code detector. Copy the internal accumulator
+    //  into the v2 shape, marking each binding as referenced
+    //  iff the file-level referenced-name set contains its name.
+    deadCode: {
+      bindings: facts.deadCode.bindings.map((b) => ({
+        ...b,
+        isReferenced: facts.referencedNames.has(b.name)
+      })),
+      constantConditions: facts.deadCode.constantConditions,
+      unreachableStatements: facts.deadCode.unreachableStatements
+    },
     componentSizes: facts.componentSizes.map((cs) => ({
       name: cs.name,
       lineCount: cs.lineCount,
@@ -6956,7 +7122,17 @@ function extractFacts(filePath, ast, source, supportsRsc = true, framework = "re
     componentSizes: [],
     astroComponents: [],
     fetchCalls: [],
-    optimisticUpdates: []
+    optimisticUpdates: [],
+    //  dead-code detector. The visitor's identifier walk + import/
+    //  branch/return handlers populate these. The v2 builder at the
+    //  bottom of extractFacts() reads them and produces
+    //  `facts.v2.deadCode`.
+    deadCode: {
+      bindings: [],
+      constantConditions: [],
+      unreachableStatements: []
+    },
+    referencedNames: /* @__PURE__ */ new Set()
   };
   const ctx = {
     stack: [],
@@ -7043,6 +7219,16 @@ function extractFacts(filePath, ast, source, supportsRsc = true, framework = "re
             propBindingSet.add(bindingName);
           }
         }
+        const { line: pLine, column: pCol } = positionFrom(param, lineOffsets);
+        for (const bindingName of collectBindingNames2(param)) {
+          facts.deadCode.bindings.push({
+            name: bindingName,
+            kind: "parameter",
+            line: pLine,
+            column: pCol,
+            isReferenced: false
+          });
+        }
       }
     }
     ctx.stack.push({
@@ -7058,6 +7244,12 @@ function extractFacts(filePath, ast, source, supportsRsc = true, framework = "re
       propUsages: [],
       isComponent,
       bindings,
+      //  dead-code detector: per-frame referenced-name set.
+      //  Identifiers encountered inside the frame are added to this
+      //  set; the deadCode builder unions it with parent frames at
+      //  pop time so a binding is considered used if any reachable
+      //  scope references it.
+      references: /* @__PURE__ */ new Set(),
       propBindingSet,
       propUsageSet: /* @__PURE__ */ new Set(),
       node
@@ -7153,6 +7345,11 @@ function extractFacts(filePath, ast, source, supportsRsc = true, framework = "re
   mergeTemplateClassNames(filePath, source, facts, templateClassNames);
   const { ext } = splitFilePath(filePath);
   facts._source = source;
+  facts.deadCode.unreachableStatements = findUnreachableStatements(
+    ast,
+    source,
+    lineOffsets
+  );
   const v2 = buildV2Facts(facts, source, ext, framework, config, templateClassNames);
   return envelopeScanFacts(filePath, v2);
 }
@@ -34287,6 +34484,170 @@ var sqlConcatRule = createRule({
   }
 });
 
+// src/rules/dead/dead-branch.ts
+var deadBranchRule = createRule({
+  id: "dead/dead-branch",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: "Literal boolean condition makes one branch statically dead",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2) return issues;
+    for (const cond of facts.v2.deadCode.constantConditions) {
+      const isWhileTrue = cond.kind === "while-true";
+      issues.push({
+        ruleId: "dead/dead-branch",
+        category: "logic",
+        severity: isWhileTrue ? "low" : "medium",
+        aiSpecific: true,
+        message: isWhileTrue ? `Infinite loop with literal condition (${cond.kind})` : `Dead branch: condition is always ${cond.condition}`,
+        line: cond.line,
+        column: cond.column,
+        advice: isWhileTrue ? `If this is an intentional infinite loop (event loop, hot loop with explicit \`break\`), add a \`// slopbrick-disable\` comment. Otherwise, replace the literal with a real condition.` : `Replace the literal with a real condition, or remove the dead branch entirely. This is the AI-iteration signature: the model toggled a feature flag to a constant or left a wrapper from a previous refactor.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/dead/unreachable.ts
+var unreachableRule = createRule({
+  id: "dead/unreachable",
+  category: "logic",
+  severity: "high",
+  aiSpecific: true,
+  description: "Statement is unreachable after an unconditional return/throw/break/continue",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2) return issues;
+    for (const u of facts.v2.deadCode.unreachableStatements) {
+      if (u.snippet === "<unreachable>") continue;
+      issues.push({
+        ruleId: "dead/unreachable",
+        category: "logic",
+        severity: "high",
+        aiSpecific: true,
+        message: `Unreachable after ${u.terminator}: ${u.snippet}`,
+        line: u.line,
+        column: u.column,
+        advice: `Remove this statement \u2014 code after a ${u.terminator} is unreachable. This is the AI-iteration signature: the model added an early ${u.terminator} for a new error path, then forgot the rest of the function body was still sitting below it.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/dead/unused-import.ts
+var unusedImportRule = createRule({
+  id: "dead/unused-import",
+  category: "logic",
+  severity: "low",
+  aiSpecific: true,
+  description: "ES module import is never referenced in the file",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2) return issues;
+    for (const binding of facts.v2.deadCode.bindings) {
+      if (binding.kind !== "import-specifier" && binding.kind !== "import-default" && binding.kind !== "import-namespace") {
+        continue;
+      }
+      if (binding.isReferenced) continue;
+      if (!binding.name) continue;
+      const source = binding.source ? ` from '${binding.source}'` : "";
+      issues.push({
+        ruleId: "dead/unused-import",
+        category: "logic",
+        severity: "low",
+        aiSpecific: true,
+        message: `Unused import: '${binding.name}'${source}`,
+        line: binding.line,
+        column: binding.column,
+        advice: `Remove the import or use '${binding.name}' somewhere in the file. This is the most common AI-iteration rot \u2014 the model added the import when it introduced a feature, then rewrote the function without cleaning up.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/dead/unused-local.ts
+var SKIP_NAMES = /* @__PURE__ */ new Set(["React", "_"]);
+var unusedLocalRule = createRule({
+  id: "dead/unused-local",
+  category: "logic",
+  severity: "low",
+  aiSpecific: true,
+  description: "Variable is declared but never read after declaration",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2) return issues;
+    for (const binding of facts.v2.deadCode.bindings) {
+      if (binding.kind !== "var" && binding.kind !== "let" && binding.kind !== "const" && binding.kind !== "function" && binding.kind !== "class" && binding.kind !== "type" && binding.kind !== "interface" && binding.kind !== "enum") {
+        continue;
+      }
+      if (binding.isReferenced) continue;
+      if (SKIP_NAMES.has(binding.name)) continue;
+      if (binding.name.startsWith("_")) continue;
+      issues.push({
+        ruleId: "dead/unused-local",
+        category: "logic",
+        severity: "low",
+        aiSpecific: true,
+        message: `Unused ${binding.kind}: '${binding.name}'`,
+        line: binding.line,
+        column: binding.column,
+        advice: `Remove the declaration or use '${binding.name}' somewhere in the file. This is the second-most-common AI-iteration signature \u2014 the model declared the binding when it introduced a feature, then rewrote the function without cleaning up.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/dead/unused-parameter.ts
+var unusedParameterRule = createRule({
+  id: "dead/unused-parameter",
+  category: "logic",
+  severity: "low",
+  aiSpecific: true,
+  description: "Function parameter is declared but never read",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    if (!facts.v2) return issues;
+    for (const binding of facts.v2.deadCode.bindings) {
+      if (binding.kind !== "parameter") continue;
+      if (binding.isReferenced) continue;
+      if (binding.name.startsWith("_")) continue;
+      if (binding.name === "props") continue;
+      issues.push({
+        ruleId: "dead/unused-parameter",
+        category: "logic",
+        severity: "low",
+        aiSpecific: true,
+        message: `Unused parameter: '${binding.name}'`,
+        line: binding.line,
+        column: binding.column,
+        advice: `Remove the parameter (and update every call site) or use '${binding.name}' in the function body. This is the AI-iteration signature: the model added the parameter when it introduced a feature, then rewrote the function without removing parameters the new code does not need.`
+      });
+    }
+    return issues;
+  }
+});
+
 // src/rules/docs/broken-link.ts
 import { existsSync as existsSync4 } from "fs";
 import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
@@ -34377,6 +34738,9 @@ var expiredCodeExampleRule = createRule({
     const issues = [];
     const source = facts.v2?._source;
     if (!source) return issues;
+    const packages = declaredPackages(context.cwd);
+    const packageName = context.packageName;
+    if (packageName) packages.add(packageName);
     const blocks = extractFencedCodeBlocks(source);
     for (const block of blocks) {
       if (!CODE_LANGS.has(block.lang)) continue;
@@ -34384,7 +34748,7 @@ var expiredCodeExampleRule = createRule({
       const imports = extractImports(block.body);
       for (const imp of imports) {
         const pkgName = stripSubpath(imp);
-        if (context.packages.has(pkgName)) continue;
+        if (packages.has(pkgName)) continue;
         issues.push({
           ruleId: "docs/expired-code-example",
           category: "docs",
@@ -34405,6 +34769,7 @@ var expiredCodeExampleRule = createRule({
 import { readFileSync as readFileSync4, readdirSync, existsSync as existsSync2 } from "fs";
 import { join as join5, extname as extname3 } from "path";
 var RESERVED = /* @__PURE__ */ new Set([
+  // JS reserved words
   "true",
   "false",
   "null",
@@ -34504,7 +34869,472 @@ var RESERVED = /* @__PURE__ */ new Set([
   "next",
   "vue",
   "angular",
-  "svelte"
+  "svelte",
+  // Framework / runtime names
+  "html",
+  "astro",
+  "python",
+  "jvm",
+  "kotlin",
+  "swift",
+  "dart",
+  "ruby",
+  "rust",
+  "cpp",
+  "go",
+  "java",
+  "php",
+  "php-html",
+  "csharp",
+  "typescript",
+  "javascript",
+  "jsx",
+  "tsx",
+  "mjs",
+  "cjs",
+  "esnext",
+  "es6",
+  "es2022",
+  "es2023",
+  "esm",
+  "cjs",
+  "umd",
+  "amd",
+  "commonjs",
+  "require",
+  "module",
+  "exports",
+  "define",
+  "global",
+  "window",
+  "document",
+  "process",
+  "console",
+  "buffer",
+  "stream",
+  "fetch",
+  "axios",
+  "express",
+  "fastify",
+  "koa",
+  "hapi",
+  "nextjs",
+  "nuxt",
+  "remix",
+  "gatsby",
+  "sveltekit",
+  "solid",
+  "preact",
+  "qwik",
+  "lit",
+  "stencil",
+  "marko",
+  "alpine",
+  "stimulus",
+  "turbo",
+  "hotwire",
+  // Models / providers
+  "gpt",
+  "claude",
+  "gpt-3",
+  "gpt-3.5",
+  "gpt-4",
+  "gpt-oss",
+  "haiku",
+  "sonnet",
+  "opus",
+  "aider",
+  "tabby",
+  "copilot",
+  "cursor",
+  "windsurf",
+  "devin",
+  "claude-code",
+  // LLM-detection lingo
+  "heuristic",
+  "heuristics",
+  "calibrate",
+  "calibration",
+  "calibrator",
+  "corpus",
+  "baseline",
+  "baselines",
+  "corpus-baselines",
+  "lift",
+  "recall",
+  "precision",
+  "fpRate",
+  "ratio",
+  "verdict",
+  "USEFUL",
+  "NOISY",
+  "INVERTED",
+  "HYGIENE",
+  "DORMANT",
+  "OK",
+  "aiSpecific",
+  "defaultOff",
+  // Common slop-audit verbs/nouns
+  "commit",
+  "push",
+  "reset",
+  "rebase",
+  "merge",
+  "cherry-pick",
+  "revert",
+  "scan",
+  "parse",
+  "build",
+  "test",
+  "lint",
+  "format",
+  "check",
+  "audit",
+  "fix",
+  "patch",
+  "diff",
+  "pr",
+  "ci",
+  "cd",
+  "gh",
+  "npm",
+  "npx",
+  "pnpm",
+  "yaml",
+  "json",
+  "toml",
+  "csv",
+  "md",
+  "mdx",
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "ascii",
+  "utf8",
+  "utf-8",
+  "base64",
+  "hex",
+  "binary",
+  "text",
+  // Common design / ui terms
+  "flex",
+  "grid",
+  "auto",
+  "min",
+  "max",
+  "fill",
+  "stretch",
+  "wrap",
+  "nowrap",
+  "inline",
+  "block",
+  "hidden",
+  "visible",
+  "static",
+  "fixed",
+  "absolute",
+  "relative",
+  "sticky",
+  "pointer",
+  "cursor",
+  "focus",
+  "hover",
+  "active",
+  "disabled",
+  "readonly",
+  "primary",
+  "secondary",
+  "tertiary",
+  "success",
+  "warning",
+  "danger",
+  "info",
+  "muted",
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "xxl",
+  "xs",
+  "2xl",
+  "3xl",
+  "4xl",
+  // Math / types
+  "array",
+  "map",
+  "set",
+  "weakmap",
+  "weakset",
+  "object",
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "symbol",
+  "null",
+  "undefined",
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "readonly",
+  "private",
+  "public",
+  "protected",
+  "static",
+  "abstract",
+  "async",
+  "generator",
+  "iterator",
+  "iterable",
+  "promise",
+  "observable",
+  // Auth / domain
+  "admin",
+  "user",
+  "guest",
+  "anonymous",
+  "authenticated",
+  "unauthenticated",
+  "jwt",
+  "oauth",
+  "oidc",
+  "saml",
+  "csrf",
+  "xss",
+  "sql",
+  "nosql",
+  "orm",
+  "prisma",
+  "drizzle",
+  "sequelize",
+  "mongoose",
+  "redis",
+  "postgres",
+  "mysql",
+  "sqlite",
+  "kafka",
+  "rabbitmq",
+  "graphql",
+  "rest",
+  "grpc",
+  "websocket",
+  // slop-audit specific
+  "slopbrick",
+  "usebrick",
+  "deadcode",
+  "unused",
+  "orphan",
+  "zombie",
+  "blocker",
+  "warning",
+  "info",
+  "error",
+  "verbose",
+  "debug",
+  "silly",
+  "p50",
+  "p90",
+  "p95",
+  "p99",
+  "min",
+  "max",
+  "avg",
+  "mean",
+  "median",
+  "ratchet",
+  "tier",
+  "composite",
+  "fitness",
+  "fpr",
+  "tpr",
+  "roc",
+  "should",
+  "could",
+  "would",
+  "might",
+  "must",
+  "shall",
+  "may",
+  "can",
+  "todo",
+  "fixme",
+  "xxx",
+  "hack",
+  "note",
+  "warning",
+  "attention",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "strong",
+  "em",
+  "b",
+  "i",
+  "u",
+  "true",
+  "false",
+  "yes",
+  "no",
+  "on",
+  "off",
+  "enable",
+  "disable",
+  "ltr",
+  "rtl",
+  "auto",
+  "start",
+  "end",
+  "center",
+  "baseline",
+  "stretch",
+  "rounded",
+  "sharp",
+  "outline",
+  "ghost",
+  "link",
+  "filled",
+  "row",
+  "col",
+  "gap",
+  "pad",
+  "margin",
+  "padding",
+  "border",
+  "shadow",
+  "transparent",
+  "currentcolor",
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "hover",
+  "focus",
+  "active",
+  "disabled",
+  "checked",
+  "indeterminate",
+  "open",
+  "close",
+  "expanded",
+  "collapsed",
+  "selected",
+  "pressed",
+  // Web/CSS
+  "div",
+  "span",
+  "p",
+  "a",
+  "img",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "tr",
+  "td",
+  "th",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "figure",
+  "figcaption",
+  "main",
+  "section",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "form",
+  "input",
+  "button",
+  "select",
+  "option",
+  "textarea",
+  "label",
+  "fieldset",
+  "legend",
+  "details",
+  "summary",
+  "dialog",
+  "menu",
+  "menuitem",
+  "template",
+  "slot",
+  "picture",
+  "source",
+  "track",
+  "video",
+  "audio",
+  "canvas",
+  "svg",
+  "iframe",
+  "embed",
+  "object",
+  "portal",
+  // Common business terms
+  "api",
+  "cli",
+  "ui",
+  "ux",
+  "sdk",
+  "ide",
+  "cli",
+  "docs",
+  "doc",
+  "blog",
+  "post",
+  "page",
+  "view",
+  "tab",
+  "panel",
+  "card",
+  "list",
+  "grid",
+  "form",
+  "modal",
+  "menu",
+  "button",
+  "icon",
+  "avatar",
+  "badge",
+  "chip",
+  "tooltip",
+  "popover",
+  "dropdown",
+  "banner",
+  "alert",
+  "toast",
+  "notification",
+  "drawer",
+  "sidebar",
+  "navbar",
+  "header",
+  "footer",
+  "hero",
+  "cta",
+  "cta-primary",
+  "cta-secondary",
+  "pricing",
+  "price",
+  "cost",
+  "rate",
+  "percent",
+  "pct",
+  "count",
+  "total",
+  "small",
+  "medium",
+  "large",
+  "xl",
+  "xxl",
+  "tiny",
+  "huge"
 ]);
 var SOURCE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var SOURCE_ROOTS = ["src", "lib", "app", "components"];
@@ -34542,7 +35372,12 @@ function collectExports(cwd) {
       /\bexport\s+class\s+([A-Za-z_$][\w$]*)/g,
       /\bexport\s+interface\s+([A-Za-z_$][\w$]*)/g,
       /\bexport\s+type\s+([A-Za-z_$][\w$]*)/g,
-      /\bexport\s+default\s+(?:function\s+|class\s+)?([A-Za-z_$][\w$]*)/g
+      /\bexport\s+default\s+(?:function\s+|class\s+)?([A-Za-z_$][\w$]*)/g,
+      // v0.18.6: also collect field names from `export interface` and
+      // `export type` declarations. Without this, fields like
+      // `crossFileDrift`, `aiQuality`, `engineeringHygiene` are
+      // flagged as stale even though they're valid type fields.
+      /^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\s*[?:]/gm
     ]) {
       let m;
       while ((m = re.exec(source)) !== null) {
@@ -34553,6 +35388,21 @@ function collectExports(cwd) {
   }
   return out;
 }
+function looksLikeProseLabel(inside) {
+  const trimmed = inside.trim();
+  if (trimmed.length === 0) return false;
+  if (trimmed.startsWith("`") || trimmed.startsWith("/")) return true;
+  if (trimmed.includes("`")) return true;
+  if (/\d+\s+[a-z]/i.test(trimmed)) return true;
+  const parts = trimmed.split(",").map((s) => s.trim());
+  if (parts.length >= 3) {
+    const allNumeric = parts.every((p) => /^\d+\.?\d*$/.test(p));
+    if (!allNumeric) return true;
+  }
+  if (trimmed.length > 40 && !trimmed.includes(",")) return true;
+  if (trimmed.includes("\u2014") || trimmed.includes("\u2013")) return true;
+  return false;
+}
 var staleFunctionReferenceRule = createRule({
   id: "docs/stale-function-reference",
   category: "docs",
@@ -34572,8 +35422,39 @@ var staleFunctionReferenceRule = createRule({
       if (text.length < 3) continue;
       if (RESERVED.has(text.toLowerCase())) continue;
       if (context.exports.has(text)) continue;
-      const end = Math.min(source.length, span.index + text.length + 50);
-      if (!/\(/.test(source.slice(span.index, end))) continue;
+      const lineEnd = source.indexOf("\n", span.index);
+      const restOfLine = source.slice(
+        span.index,
+        lineEnd === -1 ? source.length : lineEnd
+      );
+      const closeTick = restOfLine.indexOf("`", 1);
+      if (closeTick === -1) continue;
+      const afterTick = restOfLine.slice(closeTick + 1);
+      const directCall = /^\s*\(/.test(afterTick);
+      let identifierRepeats = false;
+      if (!directCall) {
+        const afterSpan = restOfLine.slice(closeTick + 1);
+        const needle = text + "(";
+        identifierRepeats = afterSpan.indexOf(needle) !== -1;
+      }
+      if (!directCall && !identifierRepeats) continue;
+      const beforeTickIdx = span.index - 1;
+      const beforeChar = beforeTickIdx >= 0 ? source[beforeTickIdx] : "";
+      if (beforeChar === "." || beforeChar === "|") continue;
+      const parenStart = restOfLine.indexOf("(", closeTick);
+      const parenEnd = restOfLine.indexOf(")", parenStart);
+      if (parenStart !== -1 && parenEnd !== -1) {
+        const inside = restOfLine.slice(parenStart + 1, parenEnd);
+        const trimmed = inside.trim();
+        if (looksLikeProseLabel(inside)) continue;
+        const looksLikeTypeAnnotation = !inside.includes(":") && (/\b(string|number|boolean|null|undefined|object|array|required|optional|categorical|direct|n\/a|\bmapped\b|0[\-–][0-9]+|v[0-9]|higher is better|lower is better|added in|deprecated|pr-[0-9])\b/i.test(
+          inside
+        ) || // Short single-word label (≤ 24 chars, no `,`,
+        // doesn't look like a function arg). Real function
+        // calls are usually longer or contain commas.
+        trimmed.length > 0 && trimmed.length <= 24 && !trimmed.includes(",") && /[a-zA-Z]/.test(trimmed));
+        if (looksLikeTypeAnnotation) continue;
+      }
       issues.push({
         ruleId: "docs/stale-function-reference",
         category: "docs",
@@ -34645,7 +35526,33 @@ var ENGLISH_WORD_DENYLIST = /* @__PURE__ */ new Set([
   "jsx",
   "ok",
   "no",
-  "yes"
+  "yes",
+  // v0.18.6: common English adjectives / adverbs that frequently
+  // appear in backticked prose but are not package names.
+  "aspirational",
+  "concrete",
+  "abstract",
+  "inline",
+  "exposed",
+  "deprecated",
+  "experimental",
+  "stable",
+  "beta",
+  "alpha",
+  "wip",
+  "draft",
+  "final",
+  "shim",
+  "polyfill",
+  "stub",
+  "mock",
+  "fake",
+  "real",
+  "false",
+  "true",
+  "optional",
+  "required",
+  "default"
 ]);
 var stalePackageReferenceRule = createRule({
   id: "docs/stale-package-reference",
@@ -34807,7 +35714,9 @@ var brokenLinkRule = createRule({
       if (target.startsWith("#")) continue;
       if (target.startsWith("//")) continue;
       if (target.startsWith("/")) continue;
-      const resolved = join7(docDir, target);
+      const filePart = target.split("#")[0] ?? target;
+      if (filePart === "") continue;
+      const resolved = join7(docDir, filePart);
       if (existsSync4(resolved)) continue;
       issues.push({
         ruleId: "docs/broken-link",
@@ -39579,6 +40488,11 @@ var builtinRules = [
   missingNotNullRule,
   namingInconsistencyRule,
   sqlConcatRule,
+  deadBranchRule,
+  unreachableRule,
+  unusedImportRule,
+  unusedLocalRule,
+  unusedParameterRule,
   brokenLinkRule,
   expiredCodeExampleRule,
   staleFunctionReferenceRule,
@@ -40586,6 +41500,61 @@ var signal_strength_default = {
     _calibrationNote: "v0.17.0 ship \u2014 not in v7 per-rule table. Default-off until calibration data lands. Backed by: OWASP Foundation (2021), *OWASP Top 10 \u2014 A03:2021 Injection*, https://owasp.org/Top10/A03_2021-Injection/; OWASP Foundation (2017), *SQL Injection Prevention Cheat Sheet*. (Template-literal SQL with ${...} interpolation is the #1 SQL injection vector in AI-generated TypeScript code.)",
     aiSpecific: true
   },
+  "dead/unused-import": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    verdict: "DORMANT",
+    defaultOff: true,
+    _calibrationNote: "v0.18.5 ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The first of 5 planned `dead/*` rules (this one + dead/unused-local + dead/unused-parameter + dead/dead-branch + dead/unreachable). The pattern is the canonical AI-iteration rot: the model adds an import when introducing a feature, then rewrites the function later without cleaning up. Most real-world tsconfig.json files have `noUnusedLocals: false`, so tsc never fires.",
+    aiSpecific: true
+  },
+  "dead/unused-local": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    verdict: "DORMANT",
+    defaultOff: true,
+    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The second of 5 planned `dead/*` rules. Muchnick 1997 Ch. 13 'liveness analysis' (textbook compiler optimization).",
+    aiSpecific: true
+  },
+  "dead/unused-parameter": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    verdict: "DORMANT",
+    defaultOff: true,
+    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The third of 5 planned `dead/*` rules. AI agents add parameters when introducing features, then rewrite the function without removing parameters the new code does not need.",
+    aiSpecific: true
+  },
+  "dead/dead-branch": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    verdict: "DORMANT",
+    defaultOff: true,
+    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The fourth of 5 planned `dead/*` rules. AI-iteration signature: feature flag toggled to a constant, or wrapper from a previous refactor.",
+    aiSpecific: true
+  },
+  "dead/unreachable": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 0,
+    precision: 0,
+    lastCalibratedAt: "2026-06-30T00:00:00Z",
+    verdict: "DORMANT",
+    defaultOff: true,
+    _calibrationNote: "v0.18.5b ship \u2014 not in v7 per-rule table. Default-off until v8 calibration data lands. The fifth of 5 planned `dead/*` rules. AI-iteration signature: model added an early return for a new error path, then forgot the rest of the function body was still sitting below it.",
+    aiSpecific: true
+  },
   "docs/stale-package-reference": {
     recall: 0,
     fpRate: 0,