slopbrick 0.18.4 → 0.18.5

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";
@@ -39579,6 +39940,11 @@ var builtinRules = [
   missingNotNullRule,
   namingInconsistencyRule,
   sqlConcatRule,
+  deadBranchRule,
+  unreachableRule,
+  unusedImportRule,
+  unusedLocalRule,
+  unusedParameterRule,
   brokenLinkRule,
   expiredCodeExampleRule,
   staleFunctionReferenceRule,
@@ -40586,6 +40952,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,