slopbrick 0.19.0 → 0.21.0

package/dist/engine/worker.js

@@ -1,419 +1,13 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/engine/parser-rust.ts
-import Parser from "tree-sitter";
-import Rust from "tree-sitter-rust";
-function getRustParser() {
-  if (cachedParser) return { ok: true, parser: cachedParser };
-  if (loadError) return { ok: false, error: loadError };
-  try {
-    rustLanguage = Rust;
-    if (!rustLanguage || typeof rustLanguage !== "object") {
-      throw new Error("tree-sitter-rust: language export is missing or malformed");
-    }
-    const parser = new Parser();
-    parser.setLanguage(rustLanguage);
-    cachedParser = parser;
-    return { ok: true, parser };
-  } catch (err) {
-    loadError = err instanceof Error ? err : new Error(String(err));
-    return { ok: false, error: loadError };
-  }
-}
-function effectiveParser() {
-  if (forcedFailure) return { ok: false, error: forcedFailure };
-  return getRustParser();
-}
-function parseRust(source) {
-  const result = effectiveParser();
-  if (!result.ok) return null;
-  if (!source || source.trim() === "") return null;
-  try {
-    const rawTree = result.parser.parse(source);
-    if (!rawTree) return null;
-    const tree = rawTree;
-    if (!tree || !tree.rootNode) return null;
-    if (tree.rootNode.type === "ERROR" && tree.rootNode.childCount === 0) {
-      return null;
-    }
-    return tree;
-  } catch {
-    return null;
-  }
-}
-function isRustParserAvailable() {
-  const result = getRustParser();
-  return result.ok;
-}
-var cachedParser, rustLanguage, loadError, forcedFailure;
-var init_parser_rust = __esm({
-  "src/engine/parser-rust.ts"() {
-    "use strict";
-    cachedParser = null;
-    rustLanguage = null;
-    loadError = null;
-    forcedFailure = null;
-  }
-});
-
-// src/engine/visitors/rust.ts
-function parseRustFile(filePath, source, options = {}) {
-  const empty = {
-    imports: [],
-    functions: [],
-    structs: [],
-    traits: [],
-    impls: []
-  };
-  if (!isRustParserAvailable() || options.forceFallback) {
-    return empty;
-  }
-  const tree = parseRust(source);
-  if (!tree) return empty;
-  return walkRustTree(tree);
-}
-function walkRustTree(tree) {
-  const ctx = { inTestConfig: false };
-  const out = {
-    imports: [],
-    functions: [],
-    structs: [],
-    traits: [],
-    impls: []
-  };
-  walkChildren(tree.rootNode, ctx, out);
-  return out;
-}
-function walkChildren(node, ctx, out) {
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (!child) continue;
-    visitNode(child, ctx, out);
-  }
-}
-function visitNode(node, ctx, out) {
-  const innerCtx = { ...ctx };
-  const attrState = readPrecedingAttributes(node);
-  switch (node.type) {
-    case "use_declaration": {
-      out.imports.push(extractUse(node));
-      return;
-    }
-    case "function_item": {
-      const isMethod = isInImplBlock(node);
-      out.functions.push(extractFunction(node, attrState, innerCtx.inTestConfig, isMethod));
-      walkChildren(getField(node, "body") ?? node, innerCtx, out);
-      return;
-    }
-    case "struct_item": {
-      out.structs.push(extractStruct(node, attrState));
-      const body = getField(node, "body");
-      if (body) walkChildren(body, innerCtx, out);
-      return;
-    }
-    case "trait_item": {
-      out.traits.push(extractTrait(node, attrState));
-      const body = getField(node, "body");
-      if (body) walkChildren(body, innerCtx, out);
-      return;
-    }
-    case "impl_item": {
-      const implEntry = extractImpl(node, attrState, innerCtx);
-      out.impls.push(implEntry.entry);
-      const body = getField(node, "body");
-      if (body) walkChildren(body, innerCtx, out);
-      return;
-    }
-    case "mod_item": {
-      const modIsTest = innerCtx.inTestConfig || attrState.isTestCfg;
-      const modCtx = { ...innerCtx, inTestConfig: modIsTest };
-      const body = getField(node, "body");
-      if (body) walkChildren(body, modCtx, out);
-      return;
-    }
-    default: {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) visitNode(child, innerCtx, out);
-      }
-    }
-  }
-}
-function readPrecedingAttributes(node) {
-  const state = {
-    isTestCfg: false,
-    isTest: false,
-    isPub: false,
-    derives: []
-  };
-  const parent = node.parent;
-  if (!parent) return state;
-  for (let i = 0; i < parent.namedChildCount; i++) {
-    const sibling = parent.namedChild(i);
-    if (!sibling || sibling === node) continue;
-    if (sibling.endIndex > node.startIndex) continue;
-    if (sibling.type !== "attribute_item") continue;
-    decodeAttribute(sibling, state);
-  }
-  return state;
-}
-function decodeAttribute(attr, state) {
-  for (let i = 0; i < attr.namedChildCount; i++) {
-    const child = attr.namedChild(i);
-    if (!child || child.type !== "attribute") continue;
-    const name = firstIdentifier(child);
-    if (!name) continue;
-    if (name === "cfg") {
-      const cfgText = child.text;
-      if (/\btest\b/.test(cfgText) && !/\bnot\(test\)/.test(cfgText)) {
-        state.isTestCfg = true;
-      }
-    } else if (name === "test") {
-      state.isTest = true;
-    } else if (name === "derive") {
-      for (let j = 0; j < child.namedChildCount; j++) {
-        const inner = child.namedChild(j);
-        if (inner) {
-          const matches = inner.text.matchAll(/\b([A-Z][A-Za-z0-9_]*)\b/g);
-          for (const m of matches) state.derives.push(m[1]);
-        }
-      }
-    }
-  }
-}
-function firstIdentifier(node) {
-  const text = node.text;
-  const idMatch = text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
-  return idMatch ? idMatch[1] : null;
-}
-function extractUse(node) {
-  const text = node.text;
-  const argument = node.namedChild(0);
-  const argField = node.childForFieldName("argument");
-  const path = argField?.text ?? argument?.text ?? "";
-  const names = [];
-  let isGlob = false;
-  const useListNode = findUseListNode(argument);
-  if (useListNode) {
-    for (let i = 0; i < useListNode.namedChildCount; i++) {
-      const item = useListNode.namedChild(i);
-      if (item.type === "use_wildcard") {
-        isGlob = true;
-      } else if (item.type === "identifier") {
-        names.push({ name: item.text });
-      } else if (item.type === "use_as_clause") {
-        const alias = item.childForFieldName("alias");
-        const binding = item.childForFieldName("path");
-        if (binding) {
-          names.push({ name: binding.text, alias: alias?.text });
-        } else {
-          names.push({ name: item.text });
-        }
-      } else if (item.type === "scoped_identifier") {
-        const idents = collectIdentifiers(item);
-        names.push({ name: idents[idents.length - 1] ?? item.text });
-      } else if (item.text.includes(" as ")) {
-        const [head, alias] = item.text.split(/\s+as\s+/);
-        names.push({ name: (head ?? "").trim(), alias: alias?.trim() });
-      } else {
-        names.push({ name: item.text });
-      }
-    }
-  } else if (argument?.type === "use_wildcard") {
-    isGlob = true;
-  } else if (argument) {
-    const idents = collectIdentifiers(argument);
-    const last = idents[idents.length - 1] ?? argument.text;
-    names.push({ name: last });
-    const asMatch = text.match(/\s+as\s+(\w+)\s*;?\s*$/);
-    if (asMatch) names[0].alias = asMatch[1];
-  }
-  return {
-    path: path.trim(),
-    names,
-    isGlob,
-    line: node.startPosition.row + 1,
-    column: node.startPosition.column
-  };
-}
-function extractFunction(node, attrs, inheritedTestConfig, isMethod) {
-  const nameNode = node.childForFieldName("name");
-  const name = nameNode?.text ?? "<anon>";
-  const params = node.childForFieldName("parameters");
-  const body = node.childForFieldName("body");
-  const visibilityMod = node.namedChild(0);
-  const isPublic = visibilityMod?.type === "visibility_modifier";
-  let receiver;
-  if (isMethod && params) {
-    const selfParam = findSelfParameter(params);
-    if (selfParam) receiver = selfParam.text;
-  }
-  const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
-  const inTestConfig = inheritedTestConfig || attrs.isTest || attrs.isTestCfg || isFunctionAttrTest(node);
-  return {
-    name,
-    line: node.startPosition.row + 1,
-    column: node.startPosition.column,
-    isPublic,
-    isMethod,
-    receiver,
-    bodyLines,
-    inTestConfig
-  };
-}
-function extractStruct(node, attrs) {
-  const nameNode = node.childForFieldName("name");
-  return {
-    name: nameNode?.text ?? "<anon>",
-    line: node.startPosition.row + 1,
-    column: node.startPosition.column,
-    isPublic: hasVisibility(node),
-    isDerive: attrs.derives.length > 0,
-    derives: [...attrs.derives]
-  };
-}
-function extractTrait(node, _attrs) {
-  const nameNode = node.childForFieldName("name");
-  return {
-    name: nameNode?.text ?? "<anon>",
-    line: node.startPosition.row + 1,
-    column: node.startPosition.column,
-    isPublic: hasVisibility(node)
-  };
-}
-function extractImpl(node, _attrs, _ctx) {
-  const traitNode = node.childForFieldName("trait");
-  const typeNode = node.childForFieldName("type");
-  const typeText = typeNode?.text ?? "<anon>";
-  const traitText = traitNode?.text;
-  const body = node.childForFieldName("body");
-  const methods = [];
-  if (body) {
-    for (let i = 0; i < body.namedChildCount; i++) {
-      const child = body.namedChild(i);
-      if (child?.type === "function_item") {
-        const m = child.childForFieldName("name");
-        if (m) methods.push(m.text);
-      }
-    }
-  }
-  return {
-    entry: {
-      type: typeText,
-      trait: traitText ?? void 0,
-      methods,
-      line: node.startPosition.row + 1,
-      column: node.startPosition.column
-    }
-  };
-}
-function findUseListNode(argument) {
-  if (!argument) return null;
-  if (argument.type === "use_list") return argument;
-  if (argument.type === "scoped_use_list") {
-    for (let i = 0; i < argument.namedChildCount; i++) {
-      const c = argument.namedChild(i);
-      if (c?.type === "use_list") return c;
-    }
-  }
-  return null;
-}
-function getField(node, fieldName) {
-  return node.childForFieldName(fieldName);
-}
-function collectIdentifiers(node) {
-  const out = [];
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (!child) continue;
-    if (child.type === "identifier" || child.type === "type_identifier") {
-      out.push(child.text);
-    } else if (child.type === "scoped_identifier" || child.type === "nested_identifier") {
-      out.push(...collectIdentifiers(child));
-    }
-  }
-  return out;
-}
-function hasVisibility(node) {
-  return node.namedChild(0)?.type === "visibility_modifier";
-}
-function isInImplBlock(node) {
-  for (let p = node.parent; p; p = p.parent) {
-    if (p.type === "impl_item") return true;
-    if (p.type === "function_item" || p.type === "source_file") return false;
-  }
-  return false;
-}
-function findSelfParameter(params) {
-  for (let i = 0; i < params.namedChildCount; i++) {
-    const child = params.namedChild(i);
-    if (child?.type === "self_parameter") return child;
-  }
-  return null;
-}
-function isFunctionAttrTest(node) {
-  void node;
-  return false;
-}
-var SERVICE_SUFFIXES, SERVICE_SUFFIX_GROUP, RUST_SERVICE_STRUCT_RE, RUST_SERVICE_IMPL_RE;
-var init_rust = __esm({
-  "src/engine/visitors/rust.ts"() {
-    "use strict";
-    init_parser_rust();
-    SERVICE_SUFFIXES = [
-      "Service",
-      "Manager",
-      "Handler",
-      "Repository",
-      "Controller",
-      "Helper",
-      "Factory",
-      "Provider",
-      "Store",
-      "API",
-      "Client",
-      "Adapter",
-      "Resolver",
-      "Mapper",
-      "Transformer",
-      "Serializer",
-      "Validator",
-      "Strategy",
-      "Facade",
-      "Decorator",
-      "Observer",
-      "Builder",
-      "Command",
-      "Processor",
-      "Worker",
-      "Job",
-      "Actor",
-      "Executor"
-    ];
-    SERVICE_SUFFIX_GROUP = `(?:${SERVICE_SUFFIXES.join("|")})`;
-    RUST_SERVICE_STRUCT_RE = new RegExp(
-      `^(?:pub(?:\\(crate\\)|\\(super\\))?\\s+)?struct\\s+(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
-      "gm"
-    );
-    RUST_SERVICE_IMPL_RE = new RegExp(
-      `^impl(?:<[^>]+>)?\\s+(?:${SERVICE_SUFFIX_GROUP}\\s+for\\s+)?(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
-      "gm"
-    );
-  }
-});
-
 // src/engine/worker.ts
 import { isMainThread, parentPort, workerData } from "worker_threads";
-import { extname as extname6 } from "path";
-import { join as join12 } from "path";
+import { extname as extname4 } from "path";
+import { join as join11 } from "path";
 
 // ../engine/dist/index.js
 import { readFile, writeFile, mkdir, access } from "fs/promises";
@@ -7234,8 +6828,396 @@ function dispatchNode(node, parent, path, vctx) {
   return false;
 }
 
+// src/engine/parser-rust.ts
+import Parser from "tree-sitter";
+import Rust from "tree-sitter-rust";
+var cachedParser = null;
+var rustLanguage = null;
+var loadError = null;
+function getRustParser() {
+  if (cachedParser) return { ok: true, parser: cachedParser };
+  if (loadError) return { ok: false, error: loadError };
+  try {
+    rustLanguage = Rust;
+    if (!rustLanguage || typeof rustLanguage !== "object") {
+      throw new Error("tree-sitter-rust: language export is missing or malformed");
+    }
+    const parser = new Parser();
+    parser.setLanguage(rustLanguage);
+    cachedParser = parser;
+    return { ok: true, parser };
+  } catch (err) {
+    loadError = err instanceof Error ? err : new Error(String(err));
+    return { ok: false, error: loadError };
+  }
+}
+var forcedFailure = null;
+function effectiveParser() {
+  if (forcedFailure) return { ok: false, error: forcedFailure };
+  return getRustParser();
+}
+function parseRust(source) {
+  const result = effectiveParser();
+  if (!result.ok) return null;
+  if (!source || source.trim() === "") return null;
+  try {
+    const rawTree = result.parser.parse(source);
+    if (!rawTree) return null;
+    const tree = rawTree;
+    if (!tree || !tree.rootNode) return null;
+    if (tree.rootNode.type === "ERROR" && tree.rootNode.childCount === 0) {
+      return null;
+    }
+    return tree;
+  } catch {
+    return null;
+  }
+}
+function isRustParserAvailable() {
+  const result = getRustParser();
+  return result.ok;
+}
+
+// src/engine/visitors/rust.ts
+var SERVICE_SUFFIXES = [
+  "Service",
+  "Manager",
+  "Handler",
+  "Repository",
+  "Controller",
+  "Helper",
+  "Factory",
+  "Provider",
+  "Store",
+  "API",
+  "Client",
+  "Adapter",
+  "Resolver",
+  "Mapper",
+  "Transformer",
+  "Serializer",
+  "Validator",
+  "Strategy",
+  "Facade",
+  "Decorator",
+  "Observer",
+  "Builder",
+  "Command",
+  "Processor",
+  "Worker",
+  "Job",
+  "Actor",
+  "Executor"
+];
+var SERVICE_SUFFIX_GROUP = `(?:${SERVICE_SUFFIXES.join("|")})`;
+var RUST_SERVICE_STRUCT_RE = new RegExp(
+  `^(?:pub(?:\\(crate\\)|\\(super\\))?\\s+)?struct\\s+(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+  "gm"
+);
+var RUST_SERVICE_IMPL_RE = new RegExp(
+  `^impl(?:<[^>]+>)?\\s+(?:${SERVICE_SUFFIX_GROUP}\\s+for\\s+)?(\\w+?)${SERVICE_SUFFIX_GROUP}?\\b`,
+  "gm"
+);
+function parseRustFile(filePath, source, options = {}) {
+  const empty = {
+    imports: [],
+    functions: [],
+    structs: [],
+    traits: [],
+    impls: []
+  };
+  if (!isRustParserAvailable() || options.forceFallback) {
+    return empty;
+  }
+  const tree = parseRust(source);
+  if (!tree) return empty;
+  return walkRustTree(tree);
+}
+function walkRustTree(tree) {
+  const ctx = { inTestConfig: false };
+  const out = {
+    imports: [],
+    functions: [],
+    structs: [],
+    traits: [],
+    impls: []
+  };
+  walkChildren(tree.rootNode, ctx, out);
+  return out;
+}
+function walkChildren(node, ctx, out) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    visitNode(child, ctx, out);
+  }
+}
+function visitNode(node, ctx, out) {
+  const innerCtx = { ...ctx };
+  const attrState = readPrecedingAttributes(node);
+  switch (node.type) {
+    case "use_declaration": {
+      out.imports.push(extractUse(node));
+      return;
+    }
+    case "function_item": {
+      const isMethod = isInImplBlock(node);
+      out.functions.push(extractFunction(node, attrState, innerCtx.inTestConfig, isMethod));
+      walkChildren(getField(node, "body") ?? node, innerCtx, out);
+      return;
+    }
+    case "struct_item": {
+      out.structs.push(extractStruct(node, attrState));
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "trait_item": {
+      out.traits.push(extractTrait(node, attrState));
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "impl_item": {
+      const implEntry = extractImpl(node, attrState, innerCtx);
+      out.impls.push(implEntry.entry);
+      const body = getField(node, "body");
+      if (body) walkChildren(body, innerCtx, out);
+      return;
+    }
+    case "mod_item": {
+      const modIsTest = innerCtx.inTestConfig || attrState.isTestCfg;
+      const modCtx = { ...innerCtx, inTestConfig: modIsTest };
+      const body = getField(node, "body");
+      if (body) walkChildren(body, modCtx, out);
+      return;
+    }
+    default: {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) visitNode(child, innerCtx, out);
+      }
+    }
+  }
+}
+function readPrecedingAttributes(node) {
+  const state = {
+    isTestCfg: false,
+    isTest: false,
+    isPub: false,
+    derives: []
+  };
+  const parent = node.parent;
+  if (!parent) return state;
+  for (let i = 0; i < parent.namedChildCount; i++) {
+    const sibling = parent.namedChild(i);
+    if (!sibling || sibling === node) continue;
+    if (sibling.endIndex > node.startIndex) continue;
+    if (sibling.type !== "attribute_item") continue;
+    decodeAttribute(sibling, state);
+  }
+  return state;
+}
+function decodeAttribute(attr, state) {
+  for (let i = 0; i < attr.namedChildCount; i++) {
+    const child = attr.namedChild(i);
+    if (!child || child.type !== "attribute") continue;
+    const name = firstIdentifier(child);
+    if (!name) continue;
+    if (name === "cfg") {
+      const cfgText = child.text;
+      if (/\btest\b/.test(cfgText) && !/\bnot\(test\)/.test(cfgText)) {
+        state.isTestCfg = true;
+      }
+    } else if (name === "test") {
+      state.isTest = true;
+    } else if (name === "derive") {
+      for (let j = 0; j < child.namedChildCount; j++) {
+        const inner = child.namedChild(j);
+        if (inner) {
+          const matches = inner.text.matchAll(/\b([A-Z][A-Za-z0-9_]*)\b/g);
+          for (const m of matches) state.derives.push(m[1]);
+        }
+      }
+    }
+  }
+}
+function firstIdentifier(node) {
+  const text = node.text;
+  const idMatch = text.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  return idMatch ? idMatch[1] : null;
+}
+function extractUse(node) {
+  const text = node.text;
+  const argument = node.namedChild(0);
+  const argField = node.childForFieldName("argument");
+  const path = argField?.text ?? argument?.text ?? "";
+  const names = [];
+  let isGlob = false;
+  const useListNode = findUseListNode(argument);
+  if (useListNode) {
+    for (let i = 0; i < useListNode.namedChildCount; i++) {
+      const item = useListNode.namedChild(i);
+      if (item.type === "use_wildcard") {
+        isGlob = true;
+      } else if (item.type === "identifier") {
+        names.push({ name: item.text });
+      } else if (item.type === "use_as_clause") {
+        const alias = item.childForFieldName("alias");
+        const binding = item.childForFieldName("path");
+        if (binding) {
+          names.push({ name: binding.text, alias: alias?.text });
+        } else {
+          names.push({ name: item.text });
+        }
+      } else if (item.type === "scoped_identifier") {
+        const idents = collectIdentifiers(item);
+        names.push({ name: idents[idents.length - 1] ?? item.text });
+      } else if (item.text.includes(" as ")) {
+        const [head, alias] = item.text.split(/\s+as\s+/);
+        names.push({ name: (head ?? "").trim(), alias: alias?.trim() });
+      } else {
+        names.push({ name: item.text });
+      }
+    }
+  } else if (argument?.type === "use_wildcard") {
+    isGlob = true;
+  } else if (argument) {
+    const idents = collectIdentifiers(argument);
+    const last = idents[idents.length - 1] ?? argument.text;
+    names.push({ name: last });
+    const asMatch = text.match(/\s+as\s+(\w+)\s*;?\s*$/);
+    if (asMatch) names[0].alias = asMatch[1];
+  }
+  return {
+    path: path.trim(),
+    names,
+    isGlob,
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column
+  };
+}
+function extractFunction(node, attrs, inheritedTestConfig, isMethod) {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "<anon>";
+  const params = node.childForFieldName("parameters");
+  const body = node.childForFieldName("body");
+  const visibilityMod = node.namedChild(0);
+  const isPublic = visibilityMod?.type === "visibility_modifier";
+  let receiver;
+  if (isMethod && params) {
+    const selfParam = findSelfParameter(params);
+    if (selfParam) receiver = selfParam.text;
+  }
+  const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
+  const inTestConfig = inheritedTestConfig || attrs.isTest || attrs.isTestCfg || isFunctionAttrTest(node);
+  return {
+    name,
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic,
+    isMethod,
+    receiver,
+    bodyLines,
+    inTestConfig
+  };
+}
+function extractStruct(node, attrs) {
+  const nameNode = node.childForFieldName("name");
+  return {
+    name: nameNode?.text ?? "<anon>",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic: hasVisibility(node),
+    isDerive: attrs.derives.length > 0,
+    derives: [...attrs.derives]
+  };
+}
+function extractTrait(node, _attrs) {
+  const nameNode = node.childForFieldName("name");
+  return {
+    name: nameNode?.text ?? "<anon>",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    isPublic: hasVisibility(node)
+  };
+}
+function extractImpl(node, _attrs, _ctx) {
+  const traitNode = node.childForFieldName("trait");
+  const typeNode = node.childForFieldName("type");
+  const typeText = typeNode?.text ?? "<anon>";
+  const traitText = traitNode?.text;
+  const body = node.childForFieldName("body");
+  const methods = [];
+  if (body) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const child = body.namedChild(i);
+      if (child?.type === "function_item") {
+        const m = child.childForFieldName("name");
+        if (m) methods.push(m.text);
+      }
+    }
+  }
+  return {
+    entry: {
+      type: typeText,
+      trait: traitText ?? void 0,
+      methods,
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column
+    }
+  };
+}
+function findUseListNode(argument) {
+  if (!argument) return null;
+  if (argument.type === "use_list") return argument;
+  if (argument.type === "scoped_use_list") {
+    for (let i = 0; i < argument.namedChildCount; i++) {
+      const c = argument.namedChild(i);
+      if (c?.type === "use_list") return c;
+    }
+  }
+  return null;
+}
+function getField(node, fieldName) {
+  return node.childForFieldName(fieldName);
+}
+function collectIdentifiers(node) {
+  const out = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    if (child.type === "identifier" || child.type === "type_identifier") {
+      out.push(child.text);
+    } else if (child.type === "scoped_identifier" || child.type === "nested_identifier") {
+      out.push(...collectIdentifiers(child));
+    }
+  }
+  return out;
+}
+function hasVisibility(node) {
+  return node.namedChild(0)?.type === "visibility_modifier";
+}
+function isInImplBlock(node) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (p.type === "impl_item") return true;
+    if (p.type === "function_item" || p.type === "source_file") return false;
+  }
+  return false;
+}
+function findSelfParameter(params) {
+  for (let i = 0; i < params.namedChildCount; i++) {
+    const child = params.namedChild(i);
+    if (child?.type === "self_parameter") return child;
+  }
+  return null;
+}
+function isFunctionAttrTest(node) {
+  void node;
+  return false;
+}
+
 // src/engine/visitors/v2-build.ts
-init_rust();
 var TAILWIND_COLOR_RE = /^(?:bg|text|border|ring|from|to|via|fill|stroke)-([a-z]+-\d+|white|black|transparent|current|\[.+?\])$/;
 var TAILWIND_SPACING_RE = /^(?:[pm][xytrbl]?|gap|space-[xy])-(\d+(?:\.\d+)?)$/;
 var TAILWIND_RADIUS_RE = /^(?:rounded(?:-[a-z]+)?)-(.+)$/;
@@ -32871,8 +32853,8 @@ function getCorpusBaselines() {
 
 // src/rules/ai/comment-ratio.ts
 var MIN_FILE_LINES = 20;
-var FALLBACK_LOW = 0.05;
-var FALLBACK_HIGH = 0.45;
+var FALLBACK_LOW = 0.02;
+var FALLBACK_HIGH = 0.55;
 var LINE_COMMENT_RE = /^\s*(?:\/\/|#|--|;|%)/;
 var BLOCK_COMMENT_OPEN_RE = /\/\*/;
 var aiCommentRatioRule = createRule({
@@ -33001,9 +32983,9 @@ function std(xs) {
 
 // src/rules/ai/compression-profile.ts
 var MIN_BYTES = 2e3;
-var GZIP_RATIO_AI_THRESHOLD = 0.5;
-var MEAN_LINE_NCD_HUMAN_MAX = 0.3;
-var NCD_CV_AI_MAX = 0.5;
+var GZIP_RATIO_AI_THRESHOLD = 0.6;
+var MEAN_LINE_NCD_HUMAN_MAX = 0.25;
+var NCD_CV_AI_MAX = 0.4;
 var aiCompressionProfileRule = createRule({
   id: "ai/compression-profile",
   category: "ai",
@@ -33158,6 +33140,13 @@ var aiDefaultReactStackRule = createRule({
   category: "ai",
   severity: "low",
   aiSpecific: true,
+  // v0.20.0 calibration: v8.5 verdict = USEFUL but recall 0.001
+  // (fires 1 time per 1,000 files). The "≥3 of default stack"
+  // threshold catches almost nothing on real codebases — the
+  // default stack is now ubiquitous, so the signal is near-zero.
+  // Disable until the threshold is lowered or the rule is split
+  // into per-library detectors.
+  defaultOff: true,
   description: "File uses \u22653 of the default React stack (Next.js + TanStack Query + Zustand + shadcn/ui) \u2014 Sascha 2025 + Nam et al. MSR 2026",
   create(context) {
     return context;
@@ -33410,6 +33399,10 @@ var aiLibraryReinventionRule = createRule({
   category: "ai",
   severity: "medium",
   aiSpecific: true,
+  // v0.20.0 calibration: v8.5 verdict = USEFUL but recall 0.000
+  // (fires never on the corpus). The "≥2 reinvented patterns"
+  // threshold is too strict. Disable until rewritten.
+  defaultOff: true,
   description: "File reinvents \u22652 common patterns (date picker, form validation, chart, modal, etc.) without importing the canonical library \u2014 GitClear 2025 + Cui et al. 2025",
   create(context) {
     return context;
@@ -33596,6 +33589,12 @@ var aiMarkdownLeakageRule = createRule({
   category: "ai",
   severity: "high",
   aiSpecific: true,
+  // v0.20.0 calibration: v8.5 verdict = INVERTED (lift 65,504× but
+  // recall 0.000 — fires never on the corpus, and when it does fire
+  // it's wrong). The rule was on by default, contributing false
+  // positives to the self-scan. Disable until the rule is rewritten
+  // or the v9 corpus shows it works.
+  defaultOff: true,
   description: "Stray Markdown fence or bare language name at top of file \u2014 AI tools leak the fenced-block format into code",
   create(context) {
     return context;
@@ -34021,6 +34020,11 @@ var aiTextLikeRatioRule = createRule({
   category: "ai",
   severity: "low",
   aiSpecific: true,
+  // v0.20.0 calibration: v8.5 verdict = USEFUL but recall 0.000
+  // (fires never on the corpus). The rule is too specific to ever
+  // fire on real code — the prose-detection heuristic is too
+  // conservative. Disable until rewritten.
+  defaultOff: true,
   description: "High ratio of prose-like lines embedded in code \u2014 AI tools often leave natural-language explanations in source files (Yotkova 2026)",
   create(context) {
     return context;
@@ -35079,125 +35083,17 @@ var unusedParameterRule = createRule({
 });
 
 // src/rules/docs/broken-link.ts
-import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, join as join5, resolve } from "path";
 
 // src/engine/doc-freshness.ts
-import { readFileSync as readFileSync5, existsSync as existsSync3 } from "fs";
-import { join as join6, dirname as dirname3, relative as relative2 } from "path";
-import { globby as globby2 } from "globby";
-
-// src/mcp/patterns.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { basename as basename2, extname as extname2 } from "path";
-
-// src/engine/discover.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join4, dirname as dirname2, relative } from "path";
 import { globby } from "globby";
-import { minimatch } from "minimatch";
-import { resolve, extname, relative, sep, basename, dirname as dirname2, join as join3 } from "path";
-import { readFileSync } from "fs";
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte", ".astro", ".html"]);
-var BACKEND_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".py",
-  ".go",
-  // v0.14.0
-  ".swift",
-  ".kt",
-  ".kts",
-  ".dart",
-  ".rs",
-  ".cpp",
-  ".cc",
-  ".cxx",
-  ".c",
-  ".h",
-  ".hpp",
-  ".hxx",
-  ".java",
-  ".rb",
-  ".php"
-]);
-var ALL_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ...SOURCE_EXTENSIONS,
-  ...BACKEND_EXTENSIONS
-]);
-
-// src/config/conventions.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
-
-// src/mcp/patterns.ts
-var ESM_IMPORT_RE = /(?:^|\n)\s*(?:import\s+(?:type\s+)?(?:[\w*${},\s]+\s+from\s+)?|import\s+|export\s+(?:type\s+)?[\w*${},\s]+\s+from\s+)(['"])([^'"]+)\1/g;
-var DYNAMIC_IMPORT_RE = /import\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
-var COMMONJS_REQUIRE_RE = /require\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
-function extractImports(source) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  const push = (spec) => {
-    if (spec.startsWith(".") || spec.startsWith("/")) return;
-    if (seen.has(spec)) return;
-    seen.add(spec);
-    out.push(spec);
-  };
-  for (const re of [ESM_IMPORT_RE, DYNAMIC_IMPORT_RE, COMMONJS_REQUIRE_RE]) {
-    re.lastIndex = 0;
-    let m;
-    while ((m = re.exec(source)) !== null) {
-      push(m[2]);
-    }
-  }
-  return out;
-}
-
-// src/rules/docs/expired-code-example.ts
-var CODE_LANGS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "javascript", "typescript"]);
-function stripSubpath(spec) {
-  if (spec.startsWith("@")) return spec.split("/").slice(0, 2).join("/");
-  return spec.split("/")[0] ?? spec;
-}
-var expiredCodeExampleRule = createRule({
-  id: "docs/expired-code-example",
-  category: "docs",
-  severity: "medium",
-  aiSpecific: false,
-  description: "A fenced code example imports a package that is not declared in package.json.",
-  create(context) {
-    return { ...context, packages: declaredPackages(context.cwd) };
-  },
-  analyze(context, facts) {
-    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;
-      if (block.body.split("\n").length < 2) continue;
-      const imports = extractImports(block.body);
-      for (const imp of imports) {
-        const pkgName = stripSubpath(imp);
-        if (packages.has(pkgName)) continue;
-        issues.push({
-          ruleId: "docs/expired-code-example",
-          category: "docs",
-          severity: "medium",
-          aiSpecific: false,
-          message: `Code example imports \`${imp}\` but \`${pkgName}\` is not in package.json.`,
-          line: block.line,
-          column: block.column,
-          advice: `Add \`${pkgName}\` to package.json or update the example.`
-        });
-      }
-    }
-    return issues;
-  }
-});
 
 // src/rules/docs/stale-function-reference.ts
-import { readFileSync as readFileSync4, readdirSync, existsSync as existsSync2 } from "fs";
-import { join as join5, extname as extname3 } from "path";
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join as join3, extname } from "path";
 var RESERVED = /* @__PURE__ */ new Set([
   // JS reserved words
   "true",
@@ -35770,7 +35666,7 @@ var SOURCE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs",
 var SOURCE_ROOTS = ["src", "lib", "app", "components"];
 var CAP = 200;
 function walk(dir, out, cap) {
-  if (!existsSync2(dir) || out.length >= cap) return;
+  if (!existsSync(dir) || out.length >= cap) return;
   let entries;
   try {
     entries = readdirSync(dir, { withFileTypes: true });
@@ -35780,19 +35676,19 @@ function walk(dir, out, cap) {
   for (const entry of entries) {
     if (out.length >= cap) return;
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const full = join5(dir, entry.name);
+    const full = join3(dir, entry.name);
     if (entry.isDirectory()) walk(full, out, cap);
-    else if (entry.isFile() && SOURCE_EXTS.has(extname3(entry.name))) out.push(full);
+    else if (entry.isFile() && SOURCE_EXTS.has(extname(entry.name))) out.push(full);
   }
 }
 function collectExports(cwd) {
   const out = /* @__PURE__ */ new Set();
   const files = [];
-  for (const root of SOURCE_ROOTS) walk(join5(cwd, root), files, CAP);
+  for (const root of SOURCE_ROOTS) walk(join3(cwd, root), files, CAP);
   for (const file of files) {
     let source;
     try {
-      source = readFileSync4(file, "utf-8");
+      source = readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -35805,7 +35701,7 @@ function collectExports(cwd) {
       /\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
+      // `crossFileDrift`, `aiSlopScore`, `engineeringHygiene` are
       // flagged as stale even though they're valid type fields.
       /^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\s*[?:]/gm
     ]) {
@@ -36055,38 +35951,6 @@ function extractInlineCodeSpans(source) {
   }
   return hits;
 }
-function extractFencedCodeBlocks(source) {
-  const blocks = [];
-  const lines = source.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i] ?? "";
-    const fenceMatch = /^```(\w*)\s*$/.exec(line);
-    if (!fenceMatch) {
-      i++;
-      continue;
-    }
-    const lang = fenceMatch[1] ?? "";
-    const startLine = i + 1;
-    const bodyLines = [];
-    i++;
-    while (i < lines.length) {
-      if (/^```\s*$/.test(lines[i] ?? "")) {
-        i++;
-        break;
-      }
-      bodyLines.push(lines[i] ?? "");
-      i++;
-    }
-    blocks.push({
-      lang,
-      body: bodyLines.join("\n"),
-      line: startLine,
-      column: 1
-    });
-  }
-  return blocks;
-}
 function extractMarkdownLinks(source) {
   const hits = [];
   const re = /(?<!\!)\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
@@ -36103,10 +35967,10 @@ function extractMarkdownLinks(source) {
 }
 function declaredPackages(cwd) {
   const out = /* @__PURE__ */ new Set();
-  const pkgPath = join6(cwd, "package.json");
-  if (!existsSync3(pkgPath)) return out;
+  const pkgPath = join4(cwd, "package.json");
+  if (!existsSync2(pkgPath)) return out;
   try {
-    const raw = readFileSync5(pkgPath, "utf-8");
+    const raw = readFileSync2(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     for (const k of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
       const v = pkg[k];
@@ -36136,7 +36000,7 @@ var brokenLinkRule = createRule({
     const source = facts.v2?._source;
     if (!source) return issues;
     const links = extractMarkdownLinks(source);
-    const docDir = dirname4(resolve2(context.cwd, context.filePath));
+    const docDir = dirname3(resolve(context.cwd, context.filePath));
     for (const link of links) {
       const target = link.target;
       if (target.startsWith("http://") || target.startsWith("https://")) continue;
@@ -36146,8 +36010,8 @@ var brokenLinkRule = createRule({
       if (target.startsWith("/")) continue;
       const filePart = target.split("#")[0] ?? target;
       if (filePart === "") continue;
-      const resolved = join7(docDir, filePart);
-      if (existsSync4(resolved)) continue;
+      const resolved = join5(docDir, filePart);
+      if (existsSync3(resolved)) continue;
       issues.push({
         ruleId: "docs/broken-link",
         category: "docs",
@@ -36376,10 +36240,261 @@ var goStructTagInconsistencyRule = createRule({
   }
 });
 
+// src/rules/java/arraylist-vs-linkedlist.ts
+var NEW_LINKED_LIST_REGEX = /new\s+LinkedList\s*</g;
+var javaArraylistVsLinkedlistRule = createRule({
+  id: "java/arraylist-vs-linkedlist",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "new LinkedList<>() \u2014 use ArrayList (Effective Java, Item 28)",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    NEW_LINKED_LIST_REGEX.lastIndex = 0;
+    while ((m = NEW_LINKED_LIST_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/arraylist-vs-linkedlist",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `new LinkedList at line ${line} \u2014 use ArrayList instead`,
+        line,
+        column: 1,
+        advice: "Replace `new LinkedList<>()` with `new ArrayList<>()`. LinkedList is rarely the right choice (worse cache locality, 5x more memory per element, O(n) indexed access). Joshua Bloch (Effective Java, Item 28) recommends ArrayList unless you specifically need a Deque. AI agents default to LinkedList because of textbook examples. Reference: java/arraylist-vs-linkedlist v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/empty-catch-block.ts
+var SINGLE_LINE_EMPTY_CATCH_REGEX = /catch\s*\([^)]*\)\s*\{\s*\}/g;
+var javaEmptyCatchBlockRule = createRule({
+  id: "java/empty-catch-block",
+  category: "logic",
+  severity: "medium",
+  aiSpecific: true,
+  description: "Empty catch block \u2014 silently swallows exceptions",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    SINGLE_LINE_EMPTY_CATCH_REGEX.lastIndex = 0;
+    while ((m = SINGLE_LINE_EMPTY_CATCH_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/empty-catch-block",
+        category: "logic",
+        severity: "medium",
+        aiSpecific: true,
+        message: `Empty catch block at line ${line} \u2014 exception is silently swallowed`,
+        line,
+        column: 1,
+        advice: 'Log the exception (`log.error("...", e)`), re-throw it, or both. Empty catch blocks hide bugs. The pattern is common in AI-generated code that wants to look defensive. Reference: java/empty-catch-block v0.20.'
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/legacy-date-api.ts
+var LEGACY_IMPORT_REGEX = /^import\s+(?:static\s+)?java\.(?:util|sql)\.(?:Date|Calendar|GregorianCalendar)\s*;/gm;
+var LEGACY_USAGE_REGEX = /\bnew\s+(?:Date|GregorianCalendar)\s*\(/g;
+var CALENDAR_GET_INSTANCE_REGEX = /Calendar\.getInstance\s*\(/g;
+var javaLegacyDateApiRule = createRule({
+  id: "java/legacy-date-api",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Legacy java.util.Date / Calendar \u2014 use java.time (JSR-310) from Java 8+",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const flagged = /* @__PURE__ */ new Set();
+    let m;
+    LEGACY_IMPORT_REGEX.lastIndex = 0;
+    while ((m = LEGACY_IMPORT_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      flagged.add(line);
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Legacy date import at line ${line} \u2014 use java.time (JSR-310) from Java 8+`,
+        line,
+        column: 1,
+        advice: "Replace `java.util.Date` / `java.util.Calendar` with `java.time` (`LocalDate`, `LocalDateTime`, `Instant`, `ZonedDateTime`). java.time is immutable, thread-safe, and has a much better API. AI agents default to the legacy API because their training data predates Java 8 (2014). Reference: java/legacy-date-api v0.20."
+      });
+    }
+    LEGACY_USAGE_REGEX.lastIndex = 0;
+    while ((m = LEGACY_USAGE_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      if (flagged.has(line)) continue;
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `new Date() / GregorianCalendar at line ${line} \u2014 use java.time`,
+        line,
+        column: 1,
+        advice: "Replace with `LocalDate.now()`, `Instant.now()`, or `ZonedDateTime.now()`. Reference: java/legacy-date-api v0.20."
+      });
+    }
+    CALENDAR_GET_INSTANCE_REGEX.lastIndex = 0;
+    while ((m = CALENDAR_GET_INSTANCE_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      if (flagged.has(line)) continue;
+      issues.push({
+        ruleId: "java/legacy-date-api",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Calendar.getInstance() at line ${line} \u2014 use java.time`,
+        line,
+        column: 1,
+        advice: "Replace with `LocalDate.now()` (date-only) or `ZonedDateTime.now()`. Reference: java/legacy-date-api v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/raw-type-overuse.ts
+var RAW_TYPE_REGEX = /\b(List|Map|Set|Collection|Iterable)\s+(?![<A-Z])(\w+)/g;
+var javaRawTypeOveruseRule = createRule({
+  id: "java/raw-type-overuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Raw type usage (List, Map, Set) \u2014 use generics (Effective Java, Item 23)",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    let m;
+    RAW_TYPE_REGEX.lastIndex = 0;
+    while ((m = RAW_TYPE_REGEX.exec(source)) !== null) {
+      const typeName = m[1];
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/raw-type-overuse",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `Raw type ${typeName} at line ${line} \u2014 add type parameters`,
+        line,
+        column: 1,
+        advice: `Replace raw \`${typeName}\` with \`${typeName}<...>\`. Raw types disable generic type checking. Effective Java, Item 23: 'Don't use raw types in new code'. AI agents default to raw types when unsure of the correct generic parameters. Reference: java/raw-type-overuse v0.20.`
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/string-concat-loop.ts
+var STRING_CONCAT_REGEX = /(\b\w+)\s*=\s*\1\s*\+\s*[^;]+;|(\b\w+)\s*\+=\s*['"`]/g;
+var javaStringConcatLoopRule = createRule({
+  id: "java/string-concat-loop",
+  category: "perf",
+  severity: "low",
+  aiSpecific: true,
+  description: "String concatenation in a loop \u2014 use StringBuilder",
+  create(_context) {
+    return {};
+  },
+  analyze(_context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\b(for|while|do)\b/.test(source)) return issues;
+    let m;
+    STRING_CONCAT_REGEX.lastIndex = 0;
+    while ((m = STRING_CONCAT_REGEX.exec(source)) !== null) {
+      const line = source.slice(0, m.index).split("\n").length;
+      issues.push({
+        ruleId: "java/string-concat-loop",
+        category: "perf",
+        severity: "low",
+        aiSpecific: true,
+        message: `String concatenation in a loop at line ${line} \u2014 use StringBuilder`,
+        line,
+        column: 1,
+        advice: "Declare a `StringBuilder` outside the loop: `StringBuilder sb = new StringBuilder(); sb.append(...);` then `return sb.toString();` after the loop. String concatenation in a loop is O(n\xB2) \u2014 each iteration copies the prior string. AI agents concatenate strings in loops because of training-data examples. Reference: java/string-concat-loop v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
+// src/rules/java/system-out-println.ts
+var PRINTLN_REGEX = /System\.out\.println\s*\(/g;
+var DEFAULT_THRESHOLD = 1;
+var javaSystemOutPrintlnRule = createRule({
+  id: "java/system-out-println",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "System.out.println in production code \u2014 use a logger (SLF4J, Log4j, etc.)",
+  create(_context) {
+    return { threshold: DEFAULT_THRESHOLD };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    const matches = [];
+    let m;
+    PRINTLN_REGEX.lastIndex = 0;
+    while ((m = PRINTLN_REGEX.exec(source)) !== null) {
+      matches.push(m.index);
+    }
+    if (matches.length <= context.threshold) return issues;
+    const cap = Math.min(matches.length, 10);
+    for (let i = 0; i < cap; i++) {
+      const idx = matches[i];
+      const line = source.slice(0, idx).split("\n").length;
+      issues.push({
+        ruleId: "java/system-out-println",
+        category: "typo",
+        severity: "low",
+        aiSpecific: true,
+        message: `System.out.println at line ${line} \u2014 use a logger for production output`,
+        line,
+        column: 1,
+        advice: "Replace with `private static final Logger log = LoggerFactory.getLogger(...);` then `log.info(...)`. AI agents default to println because their training data has countless textbook examples. Real Java code uses a logger. Reference: java/system-out-println v0.20."
+      });
+    }
+    return issues;
+  }
+});
+
 // src/rules/layout/gap-monopoly.ts
 var GAP_RE = /\bgap(?:-x|-y)?-(\d+)\b/g;
 var gapMonopolyRule = createRule({
   id: "layout/gap-monopoly",
+  // v0.20.0 calibration: recall 0.000, fires never. Disable
+  // until rewritten.
+  defaultOff: true,
   category: "layout",
   severity: "medium",
   aiSpecific: false,
@@ -36476,6 +36591,9 @@ var mathElementUniformityRule = createRule({
 var GRID_COLS_RE = /\bgrid-cols-(\d+)\b/g;
 var mathGridUniformityRule = createRule({
   id: "layout/math-grid-uniformity",
+  // v0.20.0 calibration: recall 0.000, fires never. Disable
+  // until rewritten.
+  defaultOff: true,
   category: "layout",
   severity: "high",
   aiSpecific: true,
@@ -36728,16 +36846,16 @@ var DEFAULT_CONFIG = {
 };
 
 // src/config/detect/monorepo.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync } from "fs";
-import { dirname as dirname5, join as join8, resolve as resolve3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+import { dirname as dirname4, join as join6, resolve as resolve2 } from "path";
 
 // src/config/detect/styling.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join9, resolve as resolve4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join7, resolve as resolve3 } from "path";
 
 // src/config/detect/stack.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
-import { extname as extname4, join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { extname as extname2, join as join8, resolve as resolve4 } from "path";
 
 // src/config/presets.ts
 var REACT_ONLY_RULES = {
@@ -36786,8 +36904,8 @@ var FRAMEWORK_PRESETS = {
 };
 
 // src/config/load.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname6, extname as extname5, join as join11, resolve as resolve6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname5, extname as extname3, join as join10, resolve as resolve5 } from "path";
 import { createRequire } from "module";
 
 // src/engine/logger.ts
@@ -36809,6 +36927,10 @@ function setLoggerQuiet(quiet) {
   logger = createLogger(quiet);
 }
 
+// src/config/conventions.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join9 } from "path";
+
 // src/config/init.ts
 var STRICTNESS_PRESETS = {
   strict: {
@@ -36923,6 +37045,9 @@ function checkInlineValue(value, scale) {
 }
 var spacingGridRule = createRule({
   id: "layout/spacing-grid",
+  // v0.20.0 calibration: recall 0.000, fires never. Disable
+  // until rewritten.
+  defaultOff: true,
   category: "layout",
   severity: "medium",
   aiSpecific: false,
@@ -37032,15 +37157,9 @@ var boundaryViolationRule = createRule({
     if (context.supportsRsc === false) return [];
     if (!facts.v2) return [];
     const issues = [];
-    const hookLines = /* @__PURE__ */ new Map();
-    for (const h of facts.v2.logic.hooks) {
-      const arr = hookLines.get(h.name) ?? [];
-      arr.push({ line: h.line, column: h.column });
-      hookLines.set(h.name, arr);
-    }
     for (const component of facts.v2.components) {
       if (!component.isServerComponent) continue;
-      for (const hook of facts.v2.logic.hooks) {
+      for (const hook of component.hookCalls) {
         if (!context.clientHooks.has(hook.name)) continue;
         issues.push({
           ruleId: "logic/boundary-violation",
@@ -37048,8 +37167,8 @@ var boundaryViolationRule = createRule({
           severity: "high",
           aiSpecific: true,
           message: `'${hook.name}' only works in interactive client components. This component runs on the server.`,
-          line: component.line,
-          column: component.column,
+          line: hook.line,
+          column: hook.column,
           advice: "Add the 'use client' directive at the top of this file, or move the stateful part to a separate client component.",
           fix: {
             kind: "insert",
@@ -38174,7 +38293,6 @@ function scanForStringlyParams(paramText) {
 }
 
 // src/rules/rust/todo-macro.ts
-init_parser_rust();
 var TODO_MACROS = /* @__PURE__ */ new Set(["todo", "unimplemented", "todo_unimplemented"]);
 var rustTodoMacroRule = createRule({
   id: "rust/todo-macro",
@@ -38310,7 +38428,6 @@ function collectReferencedNames(source) {
 }
 
 // src/rules/rust/unwrap-in-production.ts
-init_parser_rust();
 var UNWRAP_METHODS = /* @__PURE__ */ new Set(["unwrap", "expect", "unwrap_or_else"]);
 var rustUnwrapInProductionRule = createRule({
   id: "rust/unwrap-in-production",
@@ -39447,7 +39564,7 @@ function looksRealistic(value) {
 
 // src/rules/test/missing-edge-case.ts
 import { parseSync as parseSync2 } from "@swc/core";
-import { existsSync as existsSync9, readFileSync as readFileSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
 var MAX_PER_FILE = 20;
 var missingEdgeCaseRule = createRule({
   id: "test/missing-edge-case",
@@ -39469,7 +39586,7 @@ var missingEdgeCaseRule = createRule({
     const testFileSources = /* @__PURE__ */ new Map();
     for (const testFile of discoverTestFiles(cwd)) {
       try {
-        testFileSources.set(testFile, readFileSync10(testFile, "utf-8"));
+        testFileSources.set(testFile, readFileSync8(testFile, "utf-8"));
       } catch {
       }
     }
@@ -39835,7 +39952,12 @@ var WEAK_MATCHERS = /* @__PURE__ */ new Set([
   "toBeUndefined",
   "toBeTruthy",
   "toBeFalsy",
-  "toBeNull"
+  "toBeNull",
+  "toBeGreaterThan",
+  "toBeLessThan",
+  "toContain",
+  "toHaveLength",
+  "toBeInstanceOf"
 ]);
 function isTautologicalAssertion(hit) {
   if (hit.matcherArg && hit.expectArg && hit.expectArg === hit.matcherArg) return true;
@@ -40676,6 +40798,10 @@ function rgbToHue([r, g, b]) {
 }
 var mathColorClusterRule = createRule({
   id: "visual/math-color-cluster",
+  // v0.20.0 calibration: recall 0.000, fires never. The
+  // "math-color cluster" heuristic is too specific to ever fire
+  // on real code. Disable until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "high",
   aiSpecific: true,
@@ -40730,6 +40856,9 @@ var FONT_IMPORT_HINT_RE = /next\/font|@import\s+url|fonts\.googleapis|fonts\.gst
 var NEXT_FONT_IMPORT_RE = /import\s+.*from\s+['"]next\/font\/(?:google|local)['"]/;
 var mathDefaultFontRule = createRule({
   id: "visual/math-default-font",
+  // v0.20.0 calibration: recall 0.001, fires 1 per 1,000 files.
+  // Too specific to be useful. Disable until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "high",
   aiSpecific: true,
@@ -40796,6 +40925,9 @@ var TEXT_SIZE_MAP = {
 var TEXT_SIZE_RE = /\btext-(?:xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl)\b/g;
 var mathFontEntropyRule = createRule({
   id: "visual/math-font-entropy",
+  // v0.20.0 calibration: recall 0.004, fires 0 times on self-scan
+  // (verified). Disable until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "high",
   aiSpecific: true,
@@ -40918,6 +41050,10 @@ var ROUNDED_MAP = {
 var ROUNDED_RE = /\brounded(?:-none|-sm|-md|-lg|-xl|-2xl|-3xl|-full)?\b/g;
 var mathRoundedEntropyRule = createRule({
   id: "visual/math-rounded-entropy",
+  // v0.20.0 calibration: recall 0.004, fires 0 times on self-scan
+  // (verified). The entropy heuristic is too specific to ever fire
+  // on real code. Disable until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "high",
   aiSpecific: true,
@@ -40958,6 +41094,9 @@ var mathRoundedEntropyRule = createRule({
 var SPACING_PREFIX_RE2 = /\b(p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|gap|gap-x|gap-y)-(\d+)\b/g;
 var mathSpacingEntropyRule = createRule({
   id: "visual/math-spacing-entropy",
+  // v0.20.0 calibration: recall 0.002, fires 0 times on self-scan
+  // (verified). Disable until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "medium",
   aiSpecific: true,
@@ -40995,7 +41134,7 @@ var mathSpacingEntropyRule = createRule({
 
 // src/rules/visual/naturalness-anomaly.ts
 var MIN_LENGTH = 50;
-var DISTINCT_RATIO_FLOOR = 0.3;
+var DISTINCT_RATIO_FLOOR = 0.2;
 var naturalnessAnomalyRule = createRule({
   id: "visual/naturalness-anomaly",
   category: "visual",
@@ -41040,6 +41179,9 @@ var naturalnessAnomalyRule = createRule({
 var SCALE_TOLERANCE = 1e-3;
 var radiusScaleViolationRule = createRule({
   id: "visual/radius-scale-violation",
+  // v0.20.0 calibration: recall 0.000, fires never. Disable
+  // until rewritten.
+  defaultOff: true,
   category: "visual",
   severity: "medium",
   aiSpecific: false,
@@ -41224,6 +41366,10 @@ var ALT_HANDLER_RE = /^(?:onClick|onPointerDown|onKey(?:Down|Up|Press))$/;
 var ALT_ROLE_RE = /^(?:button|application|tab|menuitem)$/;
 var draggingMovementsRule = createRule({
   id: "wcag/dragging-movements",
+  // v0.20.0 calibration: v8.5 = DORMANT but defaultOff: false
+  // was a bug — DORMANT rules should be off by default. The
+  // rule was contributing 0 useful fires. Disable.
+  defaultOff: true,
   category: "wcag",
   severity: "medium",
   aiSpecific: false,
@@ -41370,6 +41516,11 @@ function scanForMissingAlt(source) {
 }
 var missingAltRule = createRule({
   id: "wcag/missing-alt",
+  // v0.20.0 calibration: lift 1.0, recall 0.000. Lift of 1.0
+  // means the rule has zero discriminative power — it fires
+  // equally on positive and negative examples. Dead rule.
+  // Disable until rewritten.
+  defaultOff: true,
   category: "wcag",
   severity: "medium",
   aiSpecific: false,
@@ -41590,13 +41741,18 @@ var builtinRules = [
   unusedLocalRule,
   unusedParameterRule,
   brokenLinkRule,
-  expiredCodeExampleRule,
   staleFunctionReferenceRule,
   stalePackageReferenceRule,
   dupIdenticalBlockRule,
   goErrorWrapWithoutContextRule,
   goNilSliceVsEmptyRule,
   goStructTagInconsistencyRule,
+  javaArraylistVsLinkedlistRule,
+  javaEmptyCatchBlockRule,
+  javaLegacyDateApiRule,
+  javaRawTypeOveruseRule,
+  javaStringConcatLoopRule,
+  javaSystemOutPrintlnRule,
   gapMonopolyRule,
   mathElementUniformityRule,
   mathGridUniformityRule,
@@ -42310,24 +42466,6 @@ var signal_strength_default = {
     _v8Verdict: "OK",
     _v8Lift: 48.52
   },
-  "docs/expired-code-example": {
-    recall: 0,
-    fpRate: 0,
-    ratio: 0,
-    precision: 0,
-    lastCalibratedAt: "2026-07-01T00:00:00Z",
-    verdict: "INVERTED",
-    _calibrationNote: "v8.5 calibration (v0.18.9, 2026-07-01): v7+v8 combined corpus (252080 neg + 294178 pos). v8.5 TP=0, FP=3, P=0.0%, FPR=0.00%, lift=0.00. v7 was DORMANT (TP=0, FP=0, lift=1.00). v8 was INVERTED (TP=0, FP=3).",
-    aiSpecific: false,
-    _v7Verdict: "DORMANT",
-    _v7Lift: 1,
-    _v7Recall: 0,
-    _v7FpRate: 0,
-    _v7Precision: 0,
-    _v8Verdict: "INVERTED",
-    _v8Lift: 0,
-    defaultOff: true
-  },
   "docs/stale-function-reference": {
     recall: 26e-4,
     fpRate: 5e-4,
@@ -42434,6 +42572,114 @@ var signal_strength_default = {
     _v8Lift: 1,
     defaultOff: true
   },
+  "java/arraylist-vs-linkedlist": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (new LinkedList<>() \u2014 use ArrayList (Effective Java Item 28)). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/empty-catch-block": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Empty catch block \u2014 silently swallows exceptions). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/legacy-date-api": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Legacy java.util.Date / Calendar \u2014 use java.time (JSR-310)). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/raw-type-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (Raw type usage \u2014 use generics). DORMANT until v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/string-concat-loop": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (String concat in loop \u2014 use StringBuilder). DORMANT until v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
+  "java/system-out-println": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-01T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.20: new rule (System.out.println in production code \u2014 use a logger). Not yet calibrated. Scheduled for v9 Java corpus calibration.",
+    aiSpecific: true,
+    _v7Verdict: "DORMANT",
+    _v7Lift: 1,
+    _v7Recall: 0,
+    _v7FpRate: 0,
+    _v7Precision: 0,
+    _v8Verdict: "DORMANT",
+    _v8Lift: 1,
+    defaultOff: true
+  },
   "layout/forced-layout": {
     recall: 0,
     fpRate: 0,
@@ -43690,7 +43936,7 @@ function loadSignalStrength() {
 function buildParserCacheConfig(cwd) {
   const envVal = process.env.SLOP_AUDIT_CACHE;
   const enabled = envVal === "1" || envVal === "true";
-  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? join12(cwd, ".slopbrick", "cache", "ast");
+  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? join11(cwd, ".slopbrick", "cache", "ast");
   return { enabled, root };
 }
 function applyRuleOverrides(issues, rules) {
@@ -43708,7 +43954,7 @@ function applyRuleOverrides(issues, rules) {
 }
 async function scanFile(filePath, config, registry, cwd = process.cwd()) {
   const cache = buildParserCacheConfig(cwd);
-  const ext = extname6(filePath).toLowerCase();
+  const ext = extname4(filePath).toLowerCase();
   const UNSUPPORTED_LANGS = /* @__PURE__ */ new Set([
     ".swift",
     ".kt",