lint-suite 1.6.3 → 2.0.0

package/eslint.js

@@ -4,8 +4,8 @@ import { defineConfig } from "eslint/config";
 
 // packages/lint-suite/src/lib/rules/define-plugin.util.ts
 var definePlugin = (name, rules) => {
-  const meta7 = { name };
-  const plugin = { meta: meta7, rules };
+  const meta21 = { name };
+  const plugin = { meta: meta21, rules };
   return plugin;
 };
 
@@ -14,10 +14,9 @@ import { ESLintUtils } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
 import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname as dirname2, resolve } from "node:path";
 
 // packages/lint-suite/src/lib/rules/component-metadata.ts
-import { readFileSync } from "node:fs";
 import {
   ScriptTarget,
   canHaveDecorators,
@@ -31,6 +30,114 @@ import {
   isPropertyAssignment,
   isStringLiteralLike
 } from "typescript";
+
+// packages/lint-suite/src/lib/rules/file-cache.ts
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+var CACHE_FORMAT_VERSION = 1;
+var caches = /* @__PURE__ */ new Set();
+var isFlushRegistered = false;
+var cacheDirectory = () => {
+  const { LINT_SUITE_CACHE, LINT_SUITE_CACHE_DIR } = process.env;
+  const isDisabled = LINT_SUITE_CACHE === "0";
+  if (isDisabled) return null;
+  if (LINT_SUITE_CACHE_DIR) return LINT_SUITE_CACHE_DIR;
+  return join(process.cwd(), "node_modules", ".cache", "lint-suite");
+};
+var cacheFile = (name) => {
+  const directory = cacheDirectory();
+  if (directory === null) return null;
+  return join(directory, `${name}.v${CACHE_FORMAT_VERSION}.json`);
+};
+var isCachedFile = (value) => {
+  const isObject = typeof value === "object" && value !== null;
+  if (!isObject) return false;
+  const hasVersion = "version" in value && typeof value.version === "string";
+  return hasVersion && "value" in value;
+};
+var storedEntries = (text2) => {
+  const entries = /* @__PURE__ */ new Map();
+  const parsed = JSON.parse(text2);
+  const isRecord = typeof parsed === "object" && parsed !== null;
+  if (!isRecord) return entries;
+  for (const [path, entry] of Object.entries(parsed)) {
+    if (isCachedFile(entry)) entries.set(path, entry);
+  }
+  return entries;
+};
+var load = (cache2) => {
+  cache2.loaded = true;
+  const file = cacheFile(cache2.name);
+  if (file === null) return;
+  try {
+    const stored = storedEntries(readFileSync(file, "utf8"));
+    for (const [path, entry] of stored) cache2.entries.set(path, entry);
+  } catch {
+    return;
+  }
+};
+var write = (cache2) => {
+  const file = cacheFile(cache2.name);
+  if (file === null) return;
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    const stored = Object.fromEntries(cache2.entries);
+    writeFileSync(temporary, JSON.stringify(stored));
+    renameSync(temporary, file);
+  } catch {
+    return;
+  }
+};
+var flushFileCaches = () => {
+  for (const cache2 of caches) {
+    if (!cache2.dirty) continue;
+    write(cache2);
+    cache2.dirty = false;
+  }
+};
+var registerFlush = () => {
+  if (isFlushRegistered) return;
+  isFlushRegistered = true;
+  process.once("exit", flushFileCaches);
+};
+var createFileCache = (name) => {
+  const cache2 = {
+    name,
+    entries: /* @__PURE__ */ new Map(),
+    loaded: false,
+    dirty: false
+  };
+  caches.add(cache2);
+  registerFlush();
+  return cache2;
+};
+var readCached = (cache2, path, parse2) => {
+  if (!cache2.loaded) load(cache2);
+  try {
+    const stats = statSync(path, { bigint: true });
+    const version = `${stats.mtimeNs}:${stats.size}`;
+    const cached = cache2.entries.get(path);
+    if (cached?.version === version) return cached.value;
+    const value = parse2(readFileSync(path, "utf8"), path);
+    const fresh = { value, version };
+    cache2.entries.set(path, fresh);
+    cache2.dirty = true;
+    return value;
+  } catch {
+    return null;
+  }
+};
+
+// packages/lint-suite/src/lib/rules/component-metadata.ts
+var COMPONENT_MARKER = "@Component";
+var cache = createFileCache("component-metadata");
 var componentArgument = (decorator) => {
   const { expression } = decorator;
   if (!isCallExpression(expression)) return null;
@@ -51,25 +158,6 @@ var decoratedMetadata = (node) => {
   }
   return null;
 };
-var parseComponentMetadata = (text2, path) => {
-  const found = [];
-  const visit = (node) => {
-    const metadata = decoratedMetadata(node);
-    if (metadata !== null) found.push(metadata);
-    forEachChild(node, visit);
-  };
-  const source = createSourceFile(path, text2, ScriptTarget.Latest, true);
-  forEachChild(source, visit);
-  return found;
-};
-var componentMetadata = (path) => {
-  try {
-    const text2 = readFileSync(path, "utf8");
-    return parseComponentMetadata(text2, path);
-  } catch {
-    return [];
-  }
-};
 var literalText = (node) => {
   if (!isStringLiteralLike(node)) return null;
   return node.text;
@@ -99,21 +187,51 @@ var metadataTexts = (metadata, name) => {
   if (value === null) return [];
   return literalTexts(value);
 };
+var toDescriptor = (metadata) => {
+  const [templateUrl] = metadataTexts(metadata, "templateUrl");
+  const [template] = metadataTexts(metadata, "template");
+  const styleUrl = metadataTexts(metadata, "styleUrl");
+  const listedStyleUrls = metadataTexts(metadata, "styleUrls");
+  const styleUrls = [...styleUrl, ...listedStyleUrls];
+  const styles = metadataTexts(metadata, "styles");
+  const descriptor = {
+    templateUrl: templateUrl ?? null,
+    template: template ?? null,
+    styleUrls,
+    styles
+  };
+  return descriptor;
+};
+var parseComponentMetadata = (text2, path) => {
+  const found = [];
+  const hasComponent = text2.includes(COMPONENT_MARKER);
+  if (!hasComponent) return found;
+  const visit = (node) => {
+    const metadata = decoratedMetadata(node);
+    if (metadata !== null) found.push(toDescriptor(metadata));
+    forEachChild(node, visit);
+  };
+  const source = createSourceFile(path, text2, ScriptTarget.Latest, true);
+  forEachChild(source, visit);
+  return found;
+};
+var componentMetadata = (path) => {
+  return readCached(cache, path, parseComponentMetadata) ?? [];
+};
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
 var SIBLING_EXTENSIONS = [".scss", ".css"];
 var HTML_EXTENSION = /\.html$/iu;
 var matchesTemplate = (metadata, directory, templateFilename) => {
-  const urls = metadataTexts(metadata, "templateUrl");
-  const [templateUrl] = urls;
-  if (templateUrl === void 0) return false;
+  const { templateUrl } = metadata;
+  if (templateUrl === null) return false;
   const declared = resolve(directory, templateUrl);
   const linted = resolve(templateFilename);
   return declared === linted;
 };
 var templateMetadata = (componentPath, templateFilename) => {
   const components = componentMetadata(componentPath);
-  const directory = dirname(componentPath);
+  const directory = dirname2(componentPath);
   const matches = (metadata) => {
     return matchesTemplate(metadata, directory, templateFilename);
   };
@@ -149,20 +267,16 @@ var inlineSources = (styles, componentPath) => {
 var metadataSources = (componentPath, templateFilename) => {
   const metadata = templateMetadata(componentPath, templateFilename);
   if (metadata === null) return [];
-  const singleUrl = metadataTexts(metadata, "styleUrl");
-  const listedUrls = metadataTexts(metadata, "styleUrls");
-  const styles = metadataTexts(metadata, "styles");
-  const directory = dirname(componentPath);
-  const urls = [...singleUrl, ...listedUrls];
-  const files = stylesheetFiles(urls, directory);
-  const inline = inlineSources(styles, componentPath);
+  const directory = dirname2(componentPath);
+  const files = stylesheetFiles(metadata.styleUrls, directory);
+  const inline = inlineSources(metadata.styles, componentPath);
   return [...files, ...inline];
 };
 var siblingSources = (templateFilename) => {
   const base2 = templateFilename.replace(HTML_EXTENSION, "");
   const candidateOf = (extension) => `${base2}${extension}`;
   const candidates = SIBLING_EXTENSIONS.map(candidateOf);
-  return stylesheetFiles(candidates, dirname(templateFilename));
+  return stylesheetFiles(candidates, dirname2(templateFilename));
 };
 var componentStylesheets = (templateFilename) => {
   const componentPath = templateFilename.replace(HTML_EXTENSION, ".ts");
@@ -171,14 +285,40 @@ var componentStylesheets = (templateFilename) => {
   return siblingSources(templateFilename);
 };
 
-// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
-import { readFileSync as readFileSync2, statSync } from "node:fs";
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/linked-stylesheets.ts
 import { dirname as dirname3 } from "node:path";
+
+// packages/lint-suite/src/lib/rules/utils/template-links.util.ts
+var LINK_TAG = /<link\b[^>]*>/giu;
+var STYLESHEET_REL = /\brel\s*=\s*["']stylesheet["']/iu;
+var HREF = /\bhref\s*=\s*["']([^"']*)["']/iu;
+var UNRESOLVABLE = /^(?:\/|[^:/?#]+:)/u;
+var hrefOf = (tag) => {
+  const isStylesheet = STYLESHEET_REL.test(tag);
+  if (!isStylesheet) return null;
+  const href = HREF.exec(tag)?.[1] ?? "";
+  const isUnresolvable = UNRESOLVABLE.test(href);
+  const isLocal = href.length > 0 && !isUnresolvable;
+  return isLocal ? href : null;
+};
+var linkedStylesheetHrefs = (template) => {
+  const tags = template.match(LINK_TAG) ?? [];
+  return tags.map(hrefOf).filter((href) => href !== null);
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/linked-stylesheets.ts
+var linkedStylesheets = (template, templateFilename) => {
+  const hrefs = linkedStylesheetHrefs(template);
+  return stylesheetFiles(hrefs, dirname3(templateFilename));
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
+import { dirname as dirname5 } from "node:path";
 import { parse } from "postcss-scss";
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-imports.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { basename, dirname as dirname2, join, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname4, join as join2, resolve as resolve2 } from "node:path";
 var QUOTED = /'([^']*)'|"([^"]*)"/u;
 var SKIPPED_PREFIXES = ["sass:", "http", "url("];
 var specifierOf = (params) => {
@@ -197,13 +337,13 @@ var isResolvable = (specifier) => {
 };
 var candidatesOf = (path) => {
   const isStylesheet = path.endsWith(".scss");
-  if (isStylesheet) return [path, join(dirname2(path), `_${basename(path)}`)];
-  const partial = join(dirname2(path), `_${basename(path)}.scss`);
+  if (isStylesheet) return [path, join2(dirname4(path), `_${basename(path)}`)];
+  const partial = join2(dirname4(path), `_${basename(path)}.scss`);
   return [
     `${path}.scss`,
     partial,
-    join(path, "index.scss"),
-    join(path, "_index.scss")
+    join2(path, "index.scss"),
+    join2(path, "_index.scss")
   ];
 };
 var resolveStylesheetImport = (params, directory) => {
@@ -217,7 +357,7 @@ var resolveStylesheetImport = (params, directory) => {
   return existing ?? null;
 };
 
-// packages/lint-suite/src/lib/rules/utils/selector-classes.util.ts
+// packages/lint-suite/src/lib/rules/selector-classes.ts
 import selectorParser from "postcss-selector-parser";
 var INTERPOLATION_TOKEN = "zzinterpzz";
 var PARENT_TOKEN = "zzparentzz";
@@ -335,78 +475,104 @@ var collectStylesheet = (root, directory) => {
   return entry;
 };
 
+// packages/lint-suite/src/lib/rules/utils/to-regexp.util.ts
+var toRegExp = (pattern) => new RegExp(pattern, "u");
+
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
-var stylesheets = /* @__PURE__ */ new Map();
-var emptyEntry = () => {
-  const entry = { classes: [], patterns: [], imports: [] };
-  return entry;
-};
+var EMPTY_ENTRY = { classes: [], patterns: [], imports: [] };
+var stylesheets = createFileCache("stylesheets");
+var inlineStylesheets = /* @__PURE__ */ new Map();
+var merged = /* @__PURE__ */ new Map();
 var parseStylesheet = (source, path) => {
   try {
     const root = parse(source, { from: path });
-    return collectStylesheet(root, dirname3(path));
+    return collectStylesheet(root, dirname5(path));
   } catch {
-    return emptyEntry();
+    return EMPTY_ENTRY;
   }
 };
 var fileEntry = (path) => {
-  try {
-    const stats = statSync(path, { bigint: true });
-    const version = `${stats.mtimeNs}:${stats.size}`;
-    const cached = stylesheets.get(path);
-    if (cached?.version === version) return cached.entry;
-    const entry = parseStylesheet(readFileSync2(path, "utf8"), path);
-    const fresh = { entry, version };
-    stylesheets.set(path, fresh);
-    return entry;
-  } catch {
-    return emptyEntry();
-  }
+  return readCached(stylesheets, path, parseStylesheet) ?? EMPTY_ENTRY;
+};
+var inlineEntry = (source, path) => {
+  const key2 = `${path}\0${source}`;
+  const cached = inlineStylesheets.get(key2);
+  if (cached !== void 0) return cached;
+  const entry = parseStylesheet(source, path);
+  inlineStylesheets.set(key2, entry);
+  return entry;
 };
-var addEntry = (entry, sink, visited) => {
-  for (const name of entry.classes) sink.exact.add(name);
-  sink.patterns.push(...entry.patterns);
+var collectImports = (entry, chain, visited) => {
   for (const imported of entry.imports) {
     const isVisited = visited.has(imported);
     if (isVisited) continue;
     visited.add(imported);
-    addEntry(fileEntry(imported), sink, visited);
+    const importedEntry = fileEntry(imported);
+    chain.push(importedEntry);
+    collectImports(importedEntry, chain, visited);
   }
 };
-var addSource = (source, sink, visited) => {
+var entryOf = (source) => {
+  if (source.kind === "file") return fileEntry(source.path);
+  return inlineEntry(source.source, source.path);
+};
+var collectChain = (source, chain, visited) => {
   if (source.kind === "file") {
     const isVisited = visited.has(source.path);
     if (isVisited) return;
     visited.add(source.path);
-    addEntry(fileEntry(source.path), sink, visited);
-    return;
   }
-  addEntry(parseStylesheet(source.source, source.path), sink, visited);
-};
-var toRegExp = (pattern) => {
-  return new RegExp(pattern, "u");
+  const entry = entryOf(source);
+  chain.push(entry);
+  collectImports(entry, chain, visited);
 };
-var stylesheetClasses = (sources) => {
+var mergeChain = (chain) => {
   const exact = /* @__PURE__ */ new Set();
   const patterns = [];
-  const sink = { exact, patterns };
-  const visited = /* @__PURE__ */ new Set();
-  for (const source of sources) addSource(source, sink, visited);
+  for (const entry of chain) {
+    for (const name of entry.classes) exact.add(name);
+    patterns.push(...entry.patterns);
+  }
   const compiled = patterns.map(toRegExp);
   const has = classMatcher(exact, compiled);
   const size = exact.size + compiled.length;
   const classes = { has, size };
   return classes;
 };
+var isCurrentChain = (cached, chain) => {
+  if (cached === void 0) return false;
+  if (cached.chain.length !== chain.length) return false;
+  return cached.chain.every((entry, position) => entry === chain[position]);
+};
+var sourceKey = (source) => {
+  if (source.kind === "file") return source.path;
+  return `${source.path}\0${source.source}`;
+};
+var keyOf = (sources) => {
+  return sources.map(sourceKey).join("\n");
+};
+var stylesheetClasses = (sources) => {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const source of sources) collectChain(source, chain, visited);
+  const key2 = keyOf(sources);
+  const cached = merged.get(key2);
+  if (isCurrentChain(cached, chain)) return cached.classes;
+  const classes = mergeChain(chain);
+  const fresh = { chain, classes };
+  merged.set(key2, fresh);
+  return classes;
+};
 
 // packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/template-stylesheets.ts
-var templateStylesheets = (templateFilename, cwd, globalStyles) => {
+var templateStylesheets = (templateFilename, template, cwd, globalStyles) => {
   let known = null;
   const lookup = () => {
     if (known !== null) return known;
     const component = componentStylesheets(templateFilename);
+    const linked = linkedStylesheets(template, templateFilename);
     const global = stylesheetFiles(globalStyles, cwd);
-    const sources = [...component, ...global];
+    const sources = [...component, ...linked, ...global];
     known = stylesheetClasses(sources);
     return known;
   };
@@ -497,7 +663,8 @@ var classExpressionLiterals = (source) => {
   if (ast === null) return [];
   const names = [];
   collect(ast, names);
-  return [...new Set(names)];
+  const uniqueNames = new Set(names);
+  return [...uniqueNames];
 };
 
 // packages/lint-suite/src/lib/rules/utils/template-classes.util.ts
@@ -560,10 +727,14 @@ var templateClasses = (node) => {
   const classes = [];
   for (const attribute of node.attributes) {
     const isClassName = attribute.name === CLASS_ATTRIBUTE;
-    if (isClassName) classes.push(...staticClasses(attribute));
+    if (isClassName) {
+      const found = staticClasses(attribute);
+      classes.push(...found);
+    }
   }
   for (const input of node.inputs) {
-    classes.push(...inputClasses(input));
+    const found = inputClasses(input);
+    classes.push(...found);
   }
   return classes;
 };
@@ -615,7 +786,6 @@ var isTemplateServices = (services) => {
   if (!("convertNodeSourceSpanToLoc" in services)) return false;
   return typeof services.convertNodeSourceSpanToLoc === "function";
 };
-var toRegExp2 = (pattern) => new RegExp(pattern, "u");
 var no_unstyled_classes_default = createRule({
   name: "no-unstyled-classes",
   meta,
@@ -624,9 +794,10 @@ var no_unstyled_classes_default = createRule({
     const { parserServices } = context.sourceCode;
     if (parserServices === void 0) throw new Error(PARSER_REQUIRED);
     if (!isTemplateServices(parserServices)) throw new Error(PARSER_REQUIRED);
-    const ignored = options.ignoreClassPatterns.map(toRegExp2);
+    const ignored = options.ignoreClassPatterns.map(toRegExp);
     const stylesheets2 = templateStylesheets(
       context.filename,
+      context.sourceCode.text,
       context.cwd,
       options.globalStyles
     );
@@ -645,12 +816,12 @@ var no_unstyled_classes_default = createRule({
           if (isStyled) continue;
           const loc = parserServices.convertNodeSourceSpanToLoc(span);
           const data = { name };
-          const report = {
+          const report3 = {
             loc,
             messageId: "unstyledClass",
             data
           };
-          context.report(report);
+          context.report(report3);
         }
       }
     };
@@ -671,6 +842,14 @@ var angularTemplate = defineConfig([
       "lint-suite-angular-template": lintSuiteAngularTemplatePlugin
     },
     rules: {
+      "max-lines": [
+        "error",
+        { max: 150, skipBlankLines: true, skipComments: true }
+      ],
+      // A template class name no stylesheet of the component selects is
+      // reported.
+      // Bad: class="ghost" with no .ghost rule
+      // Good: add .ghost, or drop the class
       "lint-suite-angular-template/no-unstyled-classes": "error",
       "@angular-eslint/template/prefer-template-literal": "error",
       "@angular-eslint/template/no-any": "error",
@@ -786,8 +965,8 @@ var addAngularImport = (node, imports) => {
       imports.set(specifier.local.name, null);
     } else if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
       const { imported } = specifier;
-      const isIdentifier9 = imported.type === TSESTree.AST_NODE_TYPES.Identifier;
-      const importedName = isIdentifier9 ? imported.name : imported.value;
+      const isIdentifier11 = imported.type === TSESTree.AST_NODE_TYPES.Identifier;
+      const importedName = isIdentifier11 ? imported.name : imported.value;
       imports.set(specifier.local.name, importedName);
     }
   }
@@ -818,10 +997,10 @@ var angularClassImports = (ast) => {
     }
   }
   for (const imported of imports.values()) {
-    const isNamespaceImport = imported === null;
+    const isNamespaceImport2 = imported === null;
     const isComponent = imported === "Component";
     const isDirective = imported === "Directive";
-    const isAngularClassImport = isNamespaceImport || isComponent || isDirective;
+    const isAngularClassImport = isNamespaceImport2 || isComponent || isDirective;
     if (isAngularClassImport) return imports;
   }
   return null;
@@ -841,17 +1020,20 @@ var managedApis = /* @__PURE__ */ new Set([
   "contentChild",
   "contentChildren"
 ]);
+var isManualCleanupDisabledProperty = (property) => {
+  if (property.type !== TSESTree2.AST_NODE_TYPES.Property || property.computed) {
+    return false;
+  }
+  const isIdentifierManualCleanup = property.key.type === TSESTree2.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup";
+  const isLiteralManualCleanup = property.key.type === TSESTree2.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
+  const manualCleanup = isIdentifierManualCleanup || isLiteralManualCleanup;
+  return !manualCleanup || property.value.type === TSESTree2.AST_NODE_TYPES.Literal && property.value.value === false;
+};
 var hasAutomaticEffectCleanup = (node) => {
   const options = node.arguments.at(1);
   if (options === void 0) return true;
   if (options.type !== TSESTree2.AST_NODE_TYPES.ObjectExpression) return false;
-  return options.properties.every((property) => {
-    if (property.type !== TSESTree2.AST_NODE_TYPES.Property || property.computed) {
-      return false;
-    }
-    const manualCleanup = property.key.type === TSESTree2.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup" || property.key.type === TSESTree2.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
-    return !manualCleanup || property.value.type === TSESTree2.AST_NODE_TYPES.Literal && property.value.value === false;
-  });
+  return options.properties.every(isManualCleanupDisabledProperty);
 };
 var angularCoreImportedName = (definition) => {
   if (definition?.type !== "ImportBinding") return null;
@@ -873,7 +1055,10 @@ var isAngularComponentRefField = (node, sourceCode) => {
   if (type?.type !== TSESTree2.AST_NODE_TYPES.TSTypeReference || type.typeName.type !== TSESTree2.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  const reference = sourceCode.getScope(type.typeName).references.find(({ identifier }) => identifier === type.typeName);
+  const scope = sourceCode.getScope(type.typeName);
+  const reference = scope.references.find(
+    ({ identifier }) => identifier === type.typeName
+  );
   const definition = reference?.resolved?.defs[0];
   return angularCoreImportedName(definition) === "ComponentRef";
 };
@@ -992,7 +1177,7 @@ var methodCandidate = (node, localPrivateOnly, implementedMethods) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
-import { dirname as dirname4, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, resolve as resolve3 } from "node:path";
 import { TSESTree as TSESTree5 } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-literals.ts
@@ -1036,7 +1221,7 @@ import {
   R3TargetBinder,
   parseTemplate
 } from "@angular/compiler";
-import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
 import {
@@ -1135,7 +1320,7 @@ var externalTemplateReads = (filename) => {
     const version = `${stats.mtimeNs}:${stats.size}`;
     const cached = externalTemplates.get(filename);
     if (cached?.version === version) return cached.reads;
-    const reads = templateReads(readFileSync3(filename, "utf8"), filename);
+    const reads = templateReads(readFileSync2(filename, "utf8"), filename);
     externalTemplates.set(filename, { reads, version });
     return reads;
   } catch {
@@ -1203,7 +1388,7 @@ var inlineTemplateReads = (template, reads, filename) => {
 var externalTemplatePropertyReads = (templateUrl, reads, filename) => {
   if (!templateUrl) return true;
   const url = text(templateUrl);
-  return url !== null && addReads(reads, externalTemplateReads(resolve3(dirname4(filename), url)));
+  return url !== null && addReads(reads, externalTemplateReads(resolve3(dirname6(filename), url)));
 };
 var componentTemplateReads = (metadata, reads, filename) => {
   const template = metadataValue2(metadata, "template");
@@ -1236,7 +1421,13 @@ var memberCandidates = (node, options) => {
   const implementedMethods = implementedFormsMethods(node);
   const members = [];
   for (const element of node.body.body) {
-    const candidate = fieldCandidate(element, options) ?? methodCandidate(element, options.localPrivateOnly, implementedMethods);
+    const fieldMatch = fieldCandidate(element, options);
+    const methodMatch = methodCandidate(
+      element,
+      options.localPrivateOnly,
+      implementedMethods
+    );
+    const candidate = fieldMatch ?? methodMatch;
     if (candidate) {
       members.push(candidate);
     }
@@ -1245,12 +1436,12 @@ var memberCandidates = (node, options) => {
 };
 var reportMember = (context, candidate) => {
   const data = { name: candidate.name };
-  const report = {
+  const report3 = {
     data,
     messageId: candidate.messageId,
     node: candidate.node.key
   };
-  context.report(report);
+  context.report(report3);
 };
 var reportUnreadMembers = (members, reads, options) => {
   for (const candidate of members) {
@@ -1261,8 +1452,8 @@ var reportUnreadMembers = (members, reads, options) => {
     reportMember(options.context, candidate);
   }
 };
-var reportClassMembers = (entry, ngClass, report) => {
-  const { options, projectAnalysis } = report;
+var reportClassMembers = (entry, ngClass, report3) => {
+  const { options, projectAnalysis } = report3;
   const isLocalOnlyClass = !ngClass.component || entry.node.abstract === true;
   const candidateOptions = {
     allowEffectFields: options.allowEffectFields,
@@ -1277,7 +1468,7 @@ var reportClassMembers = (entry, ngClass, report) => {
   if (unreadMembers.length === 0) return;
   const remainingNames = unreadMembers.map((candidate) => candidate.name);
   const readsOptions = {
-    component: ngClass.component && report.localTemplates,
+    component: ngClass.component && report3.localTemplates,
     filename: options.context.filename,
     metadata: ngClass.metadata,
     remainingNames,
@@ -1290,7 +1481,7 @@ var reportClassMembers = (entry, ngClass, report) => {
 var reportUnusedMembers = (options) => {
   const projectAnalysis = options.projectMemberUsed !== void 0;
   const localTemplates = !projectAnalysis || !options.projectIndexed();
-  const report = {
+  const report3 = {
     localTemplates,
     options,
     projectAnalysis
@@ -1299,7 +1490,7 @@ var reportUnusedMembers = (options) => {
     const ngClass = angularClassMetadata(entry.node, options.imports);
     const isDynamicClass = options.dynamicClasses.has(entry);
     if (!ngClass || isDynamicClass) continue;
-    reportClassMembers(entry, ngClass, report);
+    reportClassMembers(entry, ngClass, report3);
   }
 };
 
@@ -1544,6 +1735,7 @@ var trackDestructuringRead = (node, stack, thisStack, dynamicClasses) => {
 };
 var classReadVisitor = (classes, stack, dynamicClasses) => {
   const thisStack = [];
+  const lexicalThisListeners = lexicalThisVisitor(thisStack);
   const listeners = {
     ClassDeclaration(node) {
       enterClass(node, classes, stack, thisStack);
@@ -1559,7 +1751,7 @@ var classReadVisitor = (classes, stack, dynamicClasses) => {
       stack.pop();
       thisStack.pop();
     },
-    ...lexicalThisVisitor(thisStack),
+    ...lexicalThisListeners,
     AssignmentExpression(node) {
       trackDestructuringRead(node, stack, thisStack, dynamicClasses);
     },
@@ -1574,7 +1766,7 @@ var classReadVisitor = (classes, stack, dynamicClasses) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
-import { isClassElement, isIdentifier as isIdentifier8, isStringLiteralLike as isStringLiteralLike7 } from "typescript";
+import { isClassElement, isIdentifier as isIdentifier9, isStringLiteralLike as isStringLiteralLike8 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-directive-index.ts
 import { CssSelector, SelectorMatcher } from "@angular/compiler";
@@ -1597,7 +1789,8 @@ var classShape = ({
   return fields.join("\0");
 };
 var directiveShape = (classes) => {
-  const shapes = [...classes].map(classShape);
+  const classList = [...classes];
+  const shapes = classList.map(classShape);
   return shapes.sort().join("\n");
 };
 var parseSelector = (selector) => {
@@ -1607,10 +1800,21 @@ var parseSelector = (selector) => {
     return null;
   }
 };
+var slotsOf = /* @__PURE__ */ new WeakMap();
+var classKey = ({ declaration, name }) => {
+  return `${declaration.getSourceFile().fileName}\0${name}`;
+};
+var addSlot = (slots, angularClass2, holder) => {
+  const key2 = classKey(angularClass2);
+  const holders = slots.get(key2) ?? [];
+  holders.push(holder);
+  slots.set(key2, holders);
+};
 var buildDirectiveIndex = (classes) => {
   const byDeclaration = /* @__PURE__ */ new Map();
   const byExportAs = /* @__PURE__ */ new Map();
   const componentMatcher = new SelectorMatcher();
+  const slots = /* @__PURE__ */ new Map();
   for (const angularClass2 of classes) {
     const { component, declaration, exportAs, selector } = angularClass2;
     byDeclaration.set(declaration, angularClass2);
@@ -1618,11 +1822,14 @@ var buildDirectiveIndex = (classes) => {
       const declarations = byExportAs.get(name) ?? [];
       declarations.push(declaration);
       byExportAs.set(name, declarations);
+      addSlot(slots, angularClass2, declarations);
     }
     if (component && selector !== null) {
       const selectors = parseSelector(selector);
       if (selectors) {
-        componentMatcher.addSelectables(selectors, [declaration]);
+        const holder = [declaration];
+        componentMatcher.addSelectables(selectors, holder);
+        addSlot(slots, angularClass2, holder);
       }
     }
   }
@@ -1631,12 +1838,39 @@ var buildDirectiveIndex = (classes) => {
     byExportAs,
     componentMatcher
   };
+  slotsOf.set(directiveIndex, slots);
   return directiveIndex;
 };
+var repointHolders = (holders, previous, next) => {
+  for (const holder of holders) {
+    const position = holder.indexOf(previous);
+    if (position >= 0) holder[position] = next;
+  }
+};
+var replaceDeclarations = (index, previous, next) => {
+  const slots = slotsOf.get(index) ?? /* @__PURE__ */ new Map();
+  const nextByKey = /* @__PURE__ */ new Map();
+  for (const angularClass2 of next) {
+    nextByKey.set(classKey(angularClass2), angularClass2);
+  }
+  for (const angularClass2 of previous) {
+    const key2 = classKey(angularClass2);
+    const replacement = nextByKey.get(key2);
+    if (!replacement) continue;
+    const holders = slots.get(key2) ?? [];
+    repointHolders(holders, angularClass2.declaration, replacement.declaration);
+    index.byDeclaration.delete(angularClass2.declaration);
+    index.byDeclaration.set(replacement.declaration, replacement);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-reconciliation.ts
+import { dirname as dirname9, normalize as normalize2 } from "node:path";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
-import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import { isIdentifier as isIdentifier2, isStringLiteralLike as isStringLiteralLike2 } from "typescript";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { dirname as dirname7, normalize } from "node:path";
+import { isIdentifier as isIdentifier3, isStringLiteralLike as isStringLiteralLike3 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
 import {
@@ -1649,6 +1883,66 @@ import {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-resolved-path.ts
 import { SignatureKind, TypeFlags } from "typescript";
 
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/class-members.util.ts
+import {
+  SyntaxKind,
+  isClassLike,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isGetAccessor,
+  isIdentifier as isIdentifier2,
+  isMethodDeclaration,
+  isObjectLiteralExpression as isObjectLiteralExpression2,
+  isPrivateIdentifier,
+  isSetAccessor,
+  isSourceFile,
+  isStringLiteralLike as isStringLiteralLike2
+} from "typescript";
+var memberNameOf = (member) => {
+  const { name } = member;
+  if (!name) return null;
+  const isIdentifierName = isIdentifier2(name);
+  const isPrivateName = isPrivateIdentifier(name);
+  const isStringName = isStringLiteralLike2(name);
+  const isTextName = isIdentifierName || isPrivateName || isStringName;
+  if (!isTextName) return null;
+  return name.text;
+};
+var ownMembersNamed = (declaration, name) => {
+  const isNamed = (member) => {
+    return memberNameOf(member) === name;
+  };
+  return declaration.members.filter(isNamed);
+};
+var isObjectLiteralMember = (node) => {
+  const isMethod = isMethodDeclaration(node);
+  const isGetter = isGetAccessor(node);
+  const isSetter = isSetAccessor(node);
+  const isMember = isMethod || isGetter || isSetter;
+  if (!isMember) return false;
+  return isObjectLiteralExpression2(node.parent);
+};
+var isThisBoundary = (node) => {
+  const isDeclaration = isFunctionDeclaration(node);
+  const isExpression = isFunctionExpression(node);
+  const isFunction = isDeclaration || isExpression;
+  if (isFunction) return true;
+  return isObjectLiteralMember(node);
+};
+var thisClassOf = (node) => {
+  let current = node.parent;
+  while (!isSourceFile(current)) {
+    if (isClassLike(current)) return current;
+    const isBoundary = isThisBoundary(current);
+    if (isBoundary) return null;
+    current = current.parent;
+  }
+  return null;
+};
+var isThisExpression2 = (node) => {
+  return node.kind === SyntaxKind.ThisKeyword;
+};
+
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/type-property-symbols.util.ts
 import { IndexKind } from "typescript";
 var symbolsForName = (checker, type, name) => {
@@ -1708,6 +2002,15 @@ var memberTypes = (symbols, declaration, checker, sink) => {
   }
   return types;
 };
+var addOwnMemberPath = (declaration, names, sink) => {
+  const [only] = names;
+  const isSingle = names.length === 1 && only !== void 0;
+  if (!isSingle) return false;
+  const members = ownMembersNamed(declaration, only.name);
+  if (members.length === 0) return false;
+  for (const member of members) sink.addDeclaration(member);
+  return true;
+};
 var addResolvedPath = ({
   allowMissingRoot,
   checker,
@@ -1715,6 +2018,8 @@ var addResolvedPath = ({
   names,
   sink
 }) => {
+  const isOwnMember = addOwnMemberPath(declaration, names, sink);
+  if (isOwnMember) return true;
   let types = [checker.getTypeAtLocation(declaration)];
   const indexTypesOf = (type) => stringIndexTypes(checker, type);
   const returnTypesOf = (type) => callReturnTypes(checker, type);
@@ -1868,14 +2173,13 @@ var referenceTargets = (reference, owner, directives, scope) => {
   } else if (owner instanceof TmplAstElement) {
     directives.componentMatcher.match(
       createCssSelectorFromNode(owner),
-      (_selector, declarations) => {
-        targets.push(...declarations);
-      }
+      (_selector, declarations) => targets.push(...declarations)
     );
   }
-  const scoped = scope !== null && !scope.some(
+  const hostDirectiveInScope = scope?.some(
     (declaration) => directives.byDeclaration.get(declaration)?.hostDirectives
-  );
+  ) ?? false;
+  const scoped = scope !== null && !hostDirectiveInScope;
   if (!scoped) return targets;
   const scopedTargets = targets.filter((target) => scope.includes(target));
   return scopedTargets;
@@ -1948,6 +2252,23 @@ var addChainRead = (context, reads, boundTarget, chain) => {
   addReferenceRead(context, entity, owner, names);
   return true;
 };
+var PARSE_OPTIONS = {
+  leadingTriviaChars: [],
+  preserveWhitespaces: true
+};
+var PARSE_CACHE_SIZE = 64;
+var parsedTemplates = /* @__PURE__ */ new Map();
+var parsedTemplate = (source, fileName) => {
+  const key2 = `${fileName}\0${source}`;
+  const cached = parsedTemplates.get(key2);
+  if (cached !== void 0) return cached;
+  const parsed = parseTemplate2(source, fileName, PARSE_OPTIONS);
+  const isFull = parsedTemplates.size >= PARSE_CACHE_SIZE;
+  const [oldest] = parsedTemplates.keys();
+  if (isFull && oldest !== void 0) parsedTemplates.delete(oldest);
+  parsedTemplates.set(key2, parsed);
+  return parsed;
+};
 var addTemplateReads = ({
   angularClass: angularClass2,
   checker,
@@ -1967,7 +2288,7 @@ var addTemplateReads = ({
     scope,
     sink
   };
-  const parsed = parseTemplate2(source, fileName);
+  const parsed = parsedTemplate(source, fileName);
   if (parsed.errors?.length) {
     const error = parsed.errors[0]?.msg;
     return unparsedTemplateReads(context, source, error);
@@ -1987,28 +2308,34 @@ var addTemplateReads = ({
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
-var memberNameOf = (member) => {
+var memberNameOf2 = (member) => {
   const name = member.name;
   if (!name) return [];
-  const isIdentifierName = isIdentifier2(name);
-  const isStringName = isStringLiteralLike2(name);
+  const isIdentifierName = isIdentifier3(name);
+  const isStringName = isStringLiteralLike3(name);
   const isTextName = isIdentifierName || isStringName;
   if (!isTextName) return [];
   const names = [name.text];
   return names;
 };
 var memberNames = (declaration) => {
-  return declaration.members.flatMap(memberNameOf);
+  return declaration.members.flatMap(memberNameOf2);
 };
 var unknownTemplateNames = ({ declaration, scope }, allNames) => {
   if (scope === null) return allNames;
   const scopeNames = scope.flatMap(memberNames);
-  const names = [...memberNames(declaration), ...scopeNames];
+  const declarationNames = memberNames(declaration);
+  const names = [...declarationNames, ...scopeNames];
   return names;
 };
+var IDENTIFIER = /[A-Za-z_$][\w$]*/gu;
+var addTemplateMentions = (source, sink) => {
+  for (const [name] of source.matchAll(IDENTIFIER)) sink.addMention(name);
+};
 var templateFileVersion = (fileName) => {
   const { mtimeNs, size } = statSync3(fileName, { bigint: true });
-  const version = { fileName, mtimeNs, size };
+  const directory = dirname7(normalize(fileName));
+  const version = { directory, fileName, mtimeNs, size };
   return version;
 };
 var templateFileIsCurrent = (version) => {
@@ -2037,7 +2364,7 @@ var templateSourceOf = (angularClass2, allNames, sink, versions) => {
   const templateFileName = template.fileName;
   try {
     versions.push(templateFileVersion(templateFileName));
-    const source = readFileSync4(templateFileName, "utf8");
+    const source = readFileSync3(templateFileName, "utf8");
     const externalSource = {
       fileName: templateFileName,
       source
@@ -2067,6 +2394,7 @@ var collectAngularTemplateReads = ({
       templateVersions
     );
     if (template === null) continue;
+    addTemplateMentions(template.source, sink);
     const result = addTemplateReads({
       angularClass: angularClass2,
       checker,
@@ -2087,22 +2415,22 @@ var collectAngularTemplateReads = ({
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
 import {
   forEachChild as forEachChild2,
-  isClassLike,
+  isClassLike as isClassLike2,
   isElementAccessExpression,
   isPropertyAccessExpression
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-angular-interface-methods.ts
-import { SyntaxKind, isMethodSignature } from "typescript";
+import { SyntaxKind as SyntaxKind2, isMethodSignature } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-symbol-reads.ts
 import {
   SymbolFlags,
   isBigIntLiteral,
-  isIdentifier as isIdentifier3,
+  isIdentifier as isIdentifier4,
   isNumericLiteral,
-  isPrivateIdentifier,
-  isStringLiteralLike as isStringLiteralLike3
+  isPrivateIdentifier as isPrivateIdentifier2,
+  isStringLiteralLike as isStringLiteralLike4
 } from "typescript";
 var aliasTarget = (checker, symbol) => {
   const isAlias = (symbol.flags & SymbolFlags.Alias) !== 0;
@@ -2157,9 +2485,9 @@ var literalPropertyNames = (type) => {
   return names;
 };
 var propertyName2 = (checker, node) => {
-  const isIdentifierName = isIdentifier3(node);
-  const isPrivateName = isPrivateIdentifier(node);
-  const isStringName = isStringLiteralLike3(node);
+  const isIdentifierName = isIdentifier4(node);
+  const isPrivateName = isPrivateIdentifier2(node);
+  const isStringName = isStringLiteralLike4(node);
   const isNumericName = isNumericLiteral(node);
   const isBigIntName = isBigIntLiteral(node);
   const isLiteralName = isIdentifierName || isPrivateName || isStringName || isNumericName || isBigIntName;
@@ -2191,7 +2519,7 @@ var addImplementations = (heritageType, classType, checker, sink) => {
 var collectAngularInterfaceMethods = (node, checker, sink) => {
   const heritageClauses = node.heritageClauses ?? [];
   const implementsClauses = heritageClauses.filter(
-    (clause) => clause.token === SyntaxKind.ImplementsKeyword
+    (clause) => clause.token === SyntaxKind2.ImplementsKeyword
   );
   if (implementsClauses.length === 0) return;
   const classType = checker.getTypeAtLocation(node);
@@ -2206,18 +2534,18 @@ var collectAngularInterfaceMethods = (node, checker, sink) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
 import {
-  SyntaxKind as SyntaxKind2,
+  SyntaxKind as SyntaxKind3,
   isArrayLiteralExpression as isArrayLiteralExpression3,
   isBinaryExpression,
   isBindingElement,
-  isObjectLiteralExpression as isObjectLiteralExpression3,
+  isObjectLiteralExpression as isObjectLiteralExpression4,
   isVariableDeclaration
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-assignment-pattern-elements.ts
 import {
   isArrayLiteralExpression as isArrayLiteralExpression2,
-  isObjectLiteralExpression as isObjectLiteralExpression2,
+  isObjectLiteralExpression as isObjectLiteralExpression3,
   isOmittedExpression,
   isPropertyAssignment as isPropertyAssignment2,
   isSpreadAssignment,
@@ -2225,7 +2553,7 @@ import {
 } from "typescript";
 var nestedPattern = (expression) => {
   const isArrayLiteral = isArrayLiteralExpression2(expression);
-  const isObjectLiteral = isObjectLiteralExpression2(expression);
+  const isObjectLiteral = isObjectLiteralExpression3(expression);
   const isNested = isArrayLiteral || isObjectLiteral;
   if (!isNested) return null;
   return expression;
@@ -2287,7 +2615,7 @@ var assignmentPatternElements = (pattern, checker) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-binding-pattern-elements.ts
 import {
   isArrayBindingPattern,
-  isIdentifier as isIdentifier4,
+  isIdentifier as isIdentifier5,
   isObjectBindingPattern,
   isOmittedExpression as isOmittedExpression2
 } from "typescript";
@@ -2303,7 +2631,7 @@ var nestedPattern2 = (element) => {
 };
 var bindingNames = (checker, element) => {
   if (element.propertyName) return propertyName2(checker, element.propertyName);
-  const isIdentifierName = isIdentifier4(element.name);
+  const isIdentifierName = isIdentifier5(element.name);
   if (!isIdentifierName) return null;
   return [element.name.text];
 };
@@ -2391,6 +2719,7 @@ var collectPatternReads = (pattern, type, context) => {
     }
     for (const name of read.names ?? []) {
       consumed.add(name);
+      sink.addMention(name);
     }
     const skip = isSkippable(read, candidateNames);
     if (skip) continue;
@@ -2398,9 +2727,8 @@ var collectPatternReads = (pattern, type, context) => {
     const nested = read.nested;
     if (nested === null) continue;
     for (const symbol of symbols) {
-      const nestedType = lazyType(() => {
-        return checker.getTypeOfSymbolAtLocation(symbol, read.location);
-      });
+      const nestedTypeOf = () => checker.getTypeOfSymbolAtLocation(symbol, read.location);
+      const nestedType = lazyType(nestedTypeOf);
       collectPatternReads(nested, nestedType, context);
     }
   }
@@ -2422,10 +2750,10 @@ var collectBindingReads = (node, context) => {
 var collectAssignmentReads = (node, context) => {
   const isBinary = isBinaryExpression(node);
   if (!isBinary) return;
-  const isEqualsAssignment = node.operatorToken.kind === SyntaxKind2.EqualsToken;
+  const isEqualsAssignment = node.operatorToken.kind === SyntaxKind3.EqualsToken;
   if (!isEqualsAssignment) return;
   const isArrayTarget = isArrayLiteralExpression3(node.left);
-  const isObjectTarget = isObjectLiteralExpression3(node.left);
+  const isObjectTarget = isObjectLiteralExpression4(node.left);
   const isDestructuringAssignment = isArrayTarget || isObjectTarget;
   if (!isDestructuringAssignment) return;
   const rightTypeOf = () => context.checker.getTypeAtLocation(node.right);
@@ -2440,7 +2768,7 @@ var collectDestructuringReads = (node, checker, sink, candidateNames) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-write-targets.ts
 import {
-  SyntaxKind as SyntaxKind3,
+  SyntaxKind as SyntaxKind4,
   isArrayLiteralExpression as isArrayLiteralExpression4,
   isAsExpression,
   isBinaryExpression as isBinaryExpression2,
@@ -2448,7 +2776,7 @@ import {
   isForInStatement,
   isForOfStatement,
   isNonNullExpression,
-  isObjectLiteralExpression as isObjectLiteralExpression4,
+  isObjectLiteralExpression as isObjectLiteralExpression5,
   isParenthesizedExpression,
   isPropertyAssignment as isPropertyAssignment3,
   isSatisfiesExpression,
@@ -2471,7 +2799,7 @@ var isPatternContainer = (parent, child) => {
   if (isArrayLiteral) {
     return parent.elements.some((element) => element === child);
   }
-  const isObjectLiteral = isObjectLiteralExpression4(parent);
+  const isObjectLiteral = isObjectLiteralExpression5(parent);
   if (isObjectLiteral) {
     return parent.properties.some((property) => property === child);
   }
@@ -2483,7 +2811,7 @@ var isPatternContainer = (parent, child) => {
 };
 var isWriteTarget = (parent, current) => {
   const isBinary = isBinaryExpression2(parent);
-  const isBinaryTarget = isBinary && parent.left === current && parent.operatorToken.kind === SyntaxKind3.EqualsToken;
+  const isBinaryTarget = isBinary && parent.left === current && parent.operatorToken.kind === SyntaxKind4.EqualsToken;
   if (isBinaryTarget) return true;
   const isDelete = isDeleteExpression(parent);
   const isDeleteTarget = isDelete && parent.expression === current;
@@ -2504,11 +2832,24 @@ var isWriteOnly2 = (node) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
+var addOwnMemberRead = (node, sink) => {
+  const isThisAccess = isThisExpression2(node.expression);
+  if (!isThisAccess) return false;
+  const owner = thisClassOf(node);
+  if (owner === null) return false;
+  const members = ownMembersNamed(owner, node.name.text);
+  if (members.length === 0) return false;
+  for (const member of members) sink.addDeclaration(member);
+  return true;
+};
 var addPropertyAccessRead = (node, checker, sink, candidateNames) => {
+  sink.addMention(node.name.text);
   const isCandidateName = candidateNames.has(node.name.text);
   if (!isCandidateName) return;
   const isWriteTarget2 = isWriteOnly2(node);
   if (isWriteTarget2) return;
+  const isOwnMember = addOwnMemberRead(node, sink);
+  if (isOwnMember) return;
   sink.addType(checker.getTypeAtLocation(node.expression));
   const symbol = checker.getSymbolAtLocation(node.name);
   if (symbol) {
@@ -2520,6 +2861,7 @@ var addElementAccessRead = (node, checker, sink, candidateNames) => {
   if (isWriteTarget2) return;
   const argumentType = checker.getTypeAtLocation(node.argumentExpression);
   const names = literalPropertyNames(argumentType);
+  for (const name of names ?? []) sink.addMention(name);
   if (names) {
     const hasCandidateName = names.some((name) => candidateNames.has(name));
     if (!hasCandidateName) return;
@@ -2531,7 +2873,7 @@ var collectTypeScriptReads = (sourceFile, checker, sink, candidateNames) => {
   const visit = (node) => {
     const isPropertyAccess = isPropertyAccessExpression(node);
     const isElementAccess = isElementAccessExpression(node);
-    const isClass = isClassLike(node);
+    const isClass = isClassLike2(node);
     if (isPropertyAccess) {
       addPropertyAccessRead(node, checker, sink, candidateNames);
     } else if (isElementAccess) {
@@ -2631,6 +2973,7 @@ var computeEntry = (index, sourceFile, checker) => {
   const declarations = /* @__PURE__ */ new Set();
   const dependencies = /* @__PURE__ */ new Set();
   const fallbackNames = /* @__PURE__ */ new Set();
+  const mentionedNames = /* @__PURE__ */ new Set();
   const seenTypes = /* @__PURE__ */ new Set();
   const sink = {
     addDeclaration: (declaration) => {
@@ -2642,6 +2985,9 @@ var computeEntry = (index, sourceFile, checker) => {
         fallbackNames.add(name);
       }
     },
+    addMention: (name) => {
+      mentionedNames.add(name);
+    },
     addType: (type) => {
       addTypeDependencies(checker, type, dependencies, seenTypes);
     }
@@ -2653,6 +2999,7 @@ var computeEntry = (index, sourceFile, checker) => {
     declarations,
     dependencies,
     fallbackNames,
+    mentionedNames,
     sourceFile
   };
   return fileEntry2;
@@ -2664,16 +3011,16 @@ import {
   forEachChild as forEachChild3,
   getDecorators as getDecorators3,
   isCallExpression as isCallExpression3,
-  isClassLike as isClassLike3,
-  isObjectLiteralExpression as isObjectLiteralExpression5
+  isClassLike as isClassLike4,
+  isObjectLiteralExpression as isObjectLiteralExpression6
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
 import {
-  SyntaxKind as SyntaxKind4,
+  SyntaxKind as SyntaxKind5,
   isArrayLiteralExpression as isArrayLiteralExpression5,
-  isClassLike as isClassLike2,
-  isIdentifier as isIdentifier6,
+  isClassLike as isClassLike3,
+  isIdentifier as isIdentifier7,
   isPropertyAccessExpression as isPropertyAccessExpression3
 } from "typescript";
 
@@ -2684,7 +3031,7 @@ import {
   getDecorators as getDecorators2,
   isCallExpression as isCallExpression2,
   isImportDeclaration,
-  isStringLiteralLike as isStringLiteralLike4
+  isStringLiteralLike as isStringLiteralLike5
 } from "typescript";
 var decoratorKinds = [
   "Component",
@@ -2706,7 +3053,7 @@ var importedFromAngularCore = (declaration) => {
   let current = parentOf2(declaration);
   while (current) {
     if (isImportDeclaration(current)) {
-      return isStringLiteralLike4(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
+      return isStringLiteralLike5(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
     }
     current = parentOf2(current);
   }
@@ -2756,23 +3103,23 @@ var classDecoratorKind = (declaration, discovery) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-metadata-values.ts
-import { dirname as dirname5, resolve as resolve4 } from "node:path";
+import { dirname as dirname8, resolve as resolve4 } from "node:path";
 import {
-  isIdentifier as isIdentifier5,
+  isIdentifier as isIdentifier6,
   isNumericLiteral as isNumericLiteral2,
   isPropertyAccessExpression as isPropertyAccessExpression2,
   isPropertyAssignment as isPropertyAssignment4,
-  isStringLiteralLike as isStringLiteralLike5
+  isStringLiteralLike as isStringLiteralLike6
 } from "typescript";
 var stringValue = (node, discovery) => {
   if (!node) return null;
-  const isStringLiteral = isStringLiteralLike5(node);
+  const isStringLiteral = isStringLiteralLike6(node);
   if (isStringLiteral) return node.text;
-  const isIdentifierNode = isIdentifier5(node);
+  const isIdentifierNode = isIdentifier6(node);
   const isPropertyAccessNode = isPropertyAccessExpression2(node);
   if (isIdentifierNode || isPropertyAccessNode) {
     const symbol = discovery.checker.getSymbolAtLocation(
-      isIdentifier5(node) ? node : node.name
+      isIdentifier6(node) ? node : node.name
     );
     if (symbol) {
       resolveAlias(symbol, discovery);
@@ -2785,8 +3132,8 @@ var metadataProperty = (metadata, name) => {
   for (const property of metadata.properties) {
     const isAssignment = isPropertyAssignment4(property);
     if (!isAssignment) continue;
-    const isIdentifierName = isIdentifier5(property.name);
-    const isStringName = isStringLiteralLike5(property.name);
+    const isIdentifierName = isIdentifier6(property.name);
+    const isStringName = isStringLiteralLike6(property.name);
     const isNumericName = isNumericLiteral2(property.name);
     const isLiteralName = isIdentifierName || isStringName || isNumericName;
     const isPropertyNamed = isLiteralName && property.name.text === name;
@@ -2806,7 +3153,7 @@ var templateOf = (metadata, fileName, discovery) => {
   if (url) {
     const text2 = stringValue(url, discovery);
     if (text2 === null) return void 0;
-    const externalFileName = resolve4(dirname5(fileName), text2);
+    const externalFileName = resolve4(dirname8(fileName), text2);
     const externalTemplate = {
       fileName: externalFileName,
       kind: "external"
@@ -2825,14 +3172,14 @@ var exportAsOf = (metadata, discovery) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
 var booleanValue = (node) => {
   if (!node) return void 0;
-  if (node.kind === SyntaxKind4.TrueKeyword) return true;
-  if (node.kind === SyntaxKind4.FalseKeyword) return false;
+  if (node.kind === SyntaxKind5.TrueKeyword) return true;
+  if (node.kind === SyntaxKind5.FalseKeyword) return false;
   return void 0;
 };
 var classesOf = (symbol, discovery) => {
   const resolved = resolveAlias(symbol, discovery);
   const declarations = resolved.declarations ?? [];
-  return declarations.filter(isClassLike2);
+  return declarations.filter(isClassLike3);
 };
 var scopedClasses = (classes, discovery) => {
   const scoped = [];
@@ -2846,7 +3193,7 @@ var scopedClasses = (classes, discovery) => {
   return scoped;
 };
 var importedClasses = (element, discovery) => {
-  const isIdentifierElement = isIdentifier6(element);
+  const isIdentifierElement = isIdentifier7(element);
   const isPropertyAccessElement = isPropertyAccessExpression3(element);
   if (!isIdentifierElement && !isPropertyAccessElement) return null;
   const target = isIdentifierElement ? element : element.name;
@@ -2915,7 +3262,7 @@ var decoratedClass = (declaration, call, discovery) => {
     const bareDiscovery = { ...base2, valid: !component };
     return bareDiscovery;
   }
-  const isMetadataObject = isObjectLiteralExpression5(metadata);
+  const isMetadataObject = isObjectLiteralExpression6(metadata);
   if (!isMetadataObject) {
     const invalidDiscovery = { ...base2, valid: false };
     return invalidDiscovery;
@@ -2937,7 +3284,7 @@ var angularClasses = (sourceFile, checker) => {
   const classes = [];
   const discovery = { checker, dependencies: /* @__PURE__ */ new Set() };
   const visit = (node) => {
-    const isClass = isClassLike3(node);
+    const isClass = isClassLike4(node);
     if (isClass) {
       const found = angularClass(node, discovery);
       if (found) {
@@ -2975,38 +3322,51 @@ var indexableSourceFiles = (program) => {
   const sourceFiles = program.getSourceFiles();
   return sourceFiles.filter((sourceFile) => isIndexable(program, sourceFile));
 };
-var sourceFileMaps = (program) => {
-  const all = /* @__PURE__ */ new Map();
-  const current = /* @__PURE__ */ new Map();
-  for (const sourceFile of program.getSourceFiles()) {
-    all.set(sourceFile.fileName, sourceFile);
-  }
-  for (const sourceFile of indexableSourceFiles(program)) {
-    current.set(sourceFile.fileName, sourceFile);
+var adjustCounts = (counts, keys, delta) => {
+  for (const key2 of keys) {
+    const current = counts.get(key2) ?? 0;
+    const count = current + delta;
+    if (count > 0) {
+      counts.set(key2, count);
+    } else {
+      counts.delete(key2);
+    }
   }
-  const maps = { all, current };
-  return maps;
+};
+var removeEntry = (index, fileName) => {
+  const entry = index.entries.get(fileName);
+  if (!entry) return;
+  index.entries.delete(fileName);
+  adjustCounts(index.declarationCounts, entry.declarations, -1);
+  adjustCounts(index.fallbackNameCounts, entry.fallbackNames, -1);
+};
+var addEntry = (index, entry) => {
+  removeEntry(index, entry.sourceFile.fileName);
+  index.entries.set(entry.sourceFile.fileName, entry);
+  adjustCounts(index.declarationCounts, entry.declarations, 1);
+  adjustCounts(index.fallbackNameCounts, entry.fallbackNames, 1);
 };
 var dropEntries = (index, stale) => {
   for (const [fileName, entry] of index.entries) {
     const isStale = stale(entry);
-    if (isStale) {
-      index.entries.delete(fileName);
-    }
+    if (isStale) removeEntry(index, fileName);
   }
 };
-var isReplaced = (sourceFile, dependencies, maps) => {
-  const indexedSourceFile = maps.current.get(sourceFile.fileName);
-  if (indexedSourceFile !== sourceFile) return true;
+var currentSourceFiles = (program) => {
+  return new Set(program.getSourceFiles());
+};
+var isReplaced = (sourceFile, dependencies, current) => {
+  const isCurrent = current.has(sourceFile);
+  if (!isCurrent) return true;
   for (const dependency of dependencies) {
-    const indexedDependency = maps.all.get(dependency.fileName);
-    if (indexedDependency !== dependency) return true;
+    const isDependencyCurrent = current.has(dependency);
+    if (!isDependencyCurrent) return true;
   }
   return false;
 };
-var dropReplacedEntries = (index, maps) => {
+var dropReplacedEntries = (index, current) => {
   const isEntryReplaced = (entry) => {
-    return isReplaced(entry.sourceFile, entry.dependencies, maps);
+    return isReplaced(entry.sourceFile, entry.dependencies, current);
   };
   dropEntries(index, isEntryReplaced);
 };
@@ -3015,7 +3375,7 @@ var dropEntriesMentioning = (index, names) => {
   if (index.entries.size === 0) return;
   const nameList = [...names];
   const mentionsName = (entry) => {
-    return nameList.some((name) => entry.sourceFile.text.includes(name));
+    return nameList.some((name) => entry.mentionedNames.has(name));
   };
   dropEntries(index, mentionsName);
 };
@@ -3030,16 +3390,19 @@ var templateVersionChecker = () => {
     return current;
   };
 };
+var hasStaleTemplate = (entry) => {
+  return !entry.templateVersions.every(templateFileIsCurrent);
+};
 var dropStaleTemplateEntries = (index, force) => {
   const now = performance.now();
   const sinceLastCheck = now - index.templateCheckedAt;
   const isThrottled = !force && sinceLastCheck < index.templateCheckDuration * 100;
   if (isThrottled) return;
   const isCurrent = templateVersionChecker();
-  const hasStaleTemplate = (entry) => {
+  const isStale = (entry) => {
     return !entry.templateVersions.every(isCurrent);
   };
-  dropEntries(index, hasStaleTemplate);
+  dropEntries(index, isStale);
   index.templateCheckedAt = now;
   index.templateCheckDuration = performance.now() - now;
 };
@@ -3049,9 +3412,9 @@ import {
   canHaveDecorators as canHaveDecorators4,
   forEachChild as forEachChild4,
   getDecorators as getDecorators4,
-  isClassLike as isClassLike4,
-  isIdentifier as isIdentifier7,
-  isStringLiteralLike as isStringLiteralLike6
+  isClassLike as isClassLike5,
+  isIdentifier as isIdentifier8,
+  isStringLiteralLike as isStringLiteralLike7
 } from "typescript";
 var isDecoratedClass = (node) => {
   const isDecoratable = canHaveDecorators4(node);
@@ -3061,14 +3424,14 @@ var isDecoratedClass = (node) => {
   return decoratorCount > 0;
 };
 var addMemberNames = (node, names) => {
-  const isClass = isClassLike4(node);
+  const isClass = isClassLike5(node);
   if (!isClass) return;
   const isDecorated = isDecoratedClass(node);
   if (!isDecorated) return;
   for (const member of node.members) {
     if (!member.name) continue;
-    const isIdentifierName = isIdentifier7(member.name);
-    const isStringName = isStringLiteralLike6(member.name);
+    const isIdentifierName = isIdentifier8(member.name);
+    const isStringName = isStringLiteralLike7(member.name);
     const isNamedMember = isIdentifierName || isStringName;
     if (isNamedMember) {
       names.add(member.name.text);
@@ -3086,19 +3449,19 @@ var collectCandidateNames = (sourceFile) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-classes.ts
-var dropReplacedClasses = (index, maps) => {
-  let changed = false;
+var dropReplacedClasses = (index, current) => {
+  const dropped = [];
   for (const [fileName, fileClasses] of index.classes) {
     const replaced = isReplaced(
       fileClasses.sourceFile,
       fileClasses.dependencies,
-      maps
+      current
     );
     if (!replaced) continue;
     index.classes.delete(fileName);
-    changed = true;
+    dropped.push(fileClasses);
   }
-  return changed;
+  return dropped;
 };
 var addCandidateNames = (index, candidateNames, newNames) => {
   for (const name of candidateNames) {
@@ -3112,27 +3475,30 @@ var indexFileClasses = (index, sourceFile, checker, newNames) => {
   const candidateNames = collectCandidateNames(sourceFile);
   addCandidateNames(index, candidateNames, newNames);
   const { classes, dependencies } = angularClasses(sourceFile, checker());
+  const shape = directiveShape(classes);
   const fileClasses = {
     candidateNames,
     classes,
     dependencies,
+    shape,
     sourceFile
   };
   index.classes.set(sourceFile.fileName, fileClasses);
-  index.entries.delete(sourceFile.fileName);
+  removeEntry(index, sourceFile.fileName);
+  return fileClasses;
 };
 var indexNewClasses = (index, current, checker, newNames) => {
-  let changed = false;
-  for (const [fileName, sourceFile] of current) {
-    const isIndexed = index.classes.has(fileName);
+  const added = [];
+  for (const sourceFile of current) {
+    const isIndexed = index.classes.has(sourceFile.fileName);
     if (isIndexed) continue;
-    indexFileClasses(index, sourceFile, checker, newNames);
-    changed = true;
+    added.push(indexFileClasses(index, sourceFile, checker, newNames));
   }
-  return changed;
+  return added;
 };
 var rebuildDirectives = (index) => {
-  const fileClasses = [...index.classes.values()];
+  const classesValues = index.classes.values();
+  const fileClasses = [...classesValues];
   const classes = fileClasses.flatMap((entry) => entry.classes);
   const shape = directiveShape(classes);
   index.directives = buildDirectiveIndex(classes);
@@ -3140,12 +3506,26 @@ var rebuildDirectives = (index) => {
   index.directiveShape = shape;
   dropEntries(index, (entry) => entry.usedDirectiveIndex);
 };
-var reconcileClasses = (index, maps, checker) => {
+var shapesOf = (files) => {
+  return files.map((file) => file.shape).sort().join("\n");
+};
+var repointDirectives = (index, dropped, added) => {
+  const previous = dropped.flatMap((file) => file.classes);
+  const next = added.flatMap((file) => file.classes);
+  replaceDeclarations(index.directives, previous, next);
+};
+var reconcileClasses = (index, indexable, current, checker) => {
   const newNames = /* @__PURE__ */ new Set();
-  const droppedClasses = dropReplacedClasses(index, maps);
-  const addedClasses = indexNewClasses(index, maps.current, checker, newNames);
-  const changed = droppedClasses || addedClasses;
-  if (changed) {
+  const dropped = dropReplacedClasses(index, current);
+  const added = indexNewClasses(index, indexable, checker, newNames);
+  const isUntouched = dropped.length === 0 && added.length === 0;
+  if (isUntouched) return newNames;
+  const droppedShape = shapesOf(dropped);
+  const addedShape = shapesOf(added);
+  const isSameShape = droppedShape === addedShape;
+  if (isSameShape) {
+    repointDirectives(index, dropped, added);
+  } else {
     rebuildDirectives(index);
   }
   return newNames;
@@ -3160,36 +3540,59 @@ var indexMissingEntries = (index, sourceFiles, checker) => {
   for (const sourceFile of sourceFiles) {
     const isEntryIndexed = index.entries.has(sourceFile.fileName);
     if (isEntryIndexed) continue;
-    const entry = computeEntry(index, sourceFile, checker());
-    index.entries.set(sourceFile.fileName, entry);
+    addEntry(index, computeEntry(index, sourceFile, checker()));
   }
 };
 var reindexProgram = (index, program, checker) => {
-  const maps = sourceFileMaps(program);
-  dropReplacedEntries(index, maps);
-  const newNames = reconcileClasses(index, maps, checker);
+  const indexable = indexableSourceFiles(program);
+  const current = currentSourceFiles(program);
+  dropReplacedEntries(index, current);
+  const newNames = reconcileClasses(index, indexable, current, checker);
   dropEntriesMentioning(index, newNames);
   index.program = program;
-  index.usage = void 0;
-  dropStaleTemplateEntries(index, true);
-  indexMissingEntries(index, maps.current.values(), checker);
+  dropStaleTemplateEntries(index, false);
+  indexMissingEntries(index, indexable, checker);
 };
 var refreshTemplateEntries = (index, program, checker) => {
   const entryCount = index.entries.size;
   dropStaleTemplateEntries(index, false);
   const isUnchanged = index.entries.size === entryCount;
   if (isUnchanged) return;
-  index.usage = void 0;
   indexMissingEntries(index, indexableSourceFiles(program), checker);
 };
-var reconcile = (index, program) => {
+var isLocalEntry = (entry, sourceFile, directory) => {
+  const isOwn = entry.sourceFile === sourceFile;
+  if (isOwn) return true;
+  const isNearby = (version) => {
+    return version.directory === directory;
+  };
+  return entry.templateVersions.some(isNearby);
+};
+var refreshLocalEntries = (index, program, fileName, checker) => {
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) return;
+  const directory = dirname9(normalize2(sourceFile.fileName));
+  const stale = [];
+  for (const entry of index.entries.values()) {
+    if (entry.templateVersions.length === 0) continue;
+    const isLocal = isLocalEntry(entry, sourceFile, directory);
+    if (!isLocal) continue;
+    const isStale = hasStaleTemplate(entry);
+    if (isStale) stale.push(entry);
+  }
+  for (const entry of stale) {
+    addEntry(index, computeEntry(index, entry.sourceFile, checker()));
+  }
+};
+var reconcile = (index, program, fileName) => {
   const checker = lazyChecker(program);
   const isNewProgram = index.program !== program;
   if (isNewProgram) {
     reindexProgram(index, program, checker);
-    return;
+  } else {
+    refreshTemplateEntries(index, program, checker);
   }
-  refreshTemplateEntries(index, program, checker);
+  refreshLocalEntries(index, program, fileName, checker);
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
@@ -3198,46 +3601,36 @@ var memberName = (node) => {
   const isMember = isClassElement(node);
   if (!isMember) return null;
   if (!node.name) return null;
-  const isIdentifierName = isIdentifier8(node.name);
-  const isStringName = isStringLiteralLike7(node.name);
+  const isIdentifierName = isIdentifier9(node.name);
+  const isStringName = isStringLiteralLike8(node.name);
   const isNamedMember = isIdentifierName || isStringName;
   if (!isNamedMember) return null;
   return node.name.text;
 };
 var usageOf = (index) => {
-  if (index.usage !== void 0) return index.usage;
-  const declarations = /* @__PURE__ */ new Set();
-  const fallbackNames = /* @__PURE__ */ new Set();
-  for (const entry of index.entries.values()) {
-    for (const declaration of entry.declarations) {
-      declarations.add(declaration);
-    }
-    for (const name of entry.fallbackNames) {
-      fallbackNames.add(name);
-    }
-  }
-  index.usage = {
-    has: (node) => {
-      const hasDeclaration = declarations.has(node);
-      if (hasDeclaration) return true;
-      if (fallbackNames.size === 0) return false;
-      const name = memberName(node);
-      return name !== null && fallbackNames.has(name);
-    }
+  const { declarationCounts, fallbackNameCounts } = index;
+  const has = (node) => {
+    const hasDeclaration = declarationCounts.has(node);
+    if (hasDeclaration) return true;
+    if (fallbackNameCounts.size === 0) return false;
+    const name = memberName(node);
+    return name !== null && fallbackNameCounts.has(name);
   };
-  return index.usage;
+  const usage = { has };
+  return usage;
 };
 var createIndex = () => {
   const emptyIndex = {
     candidateNames: /* @__PURE__ */ new Set(),
     classes: /* @__PURE__ */ new Map(),
+    declarationCounts: /* @__PURE__ */ new Map(),
     directives: buildDirectiveIndex([]),
     directiveShape: "",
     entries: /* @__PURE__ */ new Map(),
+    fallbackNameCounts: /* @__PURE__ */ new Map(),
     program: null,
     templateCheckDuration: 0,
-    templateCheckedAt: 0,
-    usage: void 0
+    templateCheckedAt: 0
   };
   return emptyIndex;
 };
@@ -3245,7 +3638,7 @@ var projectUsageIsCurrent = (program) => {
   const configFilePath = program.getCompilerOptions()["configFilePath"];
   return typeof configFilePath === "string" && indexes.get(configFilePath)?.program === program;
 };
-var projectUsage = (program) => {
+var projectUsage = (program, fileName) => {
   const configFilePath = program.getCompilerOptions()["configFilePath"];
   if (typeof configFilePath !== "string") return null;
   let index = indexes.get(configFilePath);
@@ -3254,7 +3647,7 @@ var projectUsage = (program) => {
     indexes.set(configFilePath, index);
   }
   try {
-    reconcile(index, program);
+    reconcile(index, program, fileName);
     return usageOf(index);
   } catch {
     indexes.delete(configFilePath);
@@ -3313,12 +3706,12 @@ var projectParserServices = (context, analysis) => {
     );
   }
 };
-var projectMemberUsedFor = (parserServices) => {
+var projectMemberUsedFor = (parserServices, fileName) => {
   if (parserServices === void 0) return void 0;
   let usage;
   const memberUsed = (node) => {
     if (usage === void 0) {
-      usage = projectUsage(parserServices.program);
+      usage = projectUsage(parserServices.program, fileName);
     }
     return usage?.has(parserServices.esTreeNodeToTSNodeMap.get(node)) ?? true;
   };
@@ -3350,7 +3743,7 @@ var no_unused_angular_instance_fields_default = createRule2({
       dynamicClasses,
       imports,
       projectIndexed,
-      projectMemberUsed: projectMemberUsedFor(parserServices)
+      projectMemberUsed: projectMemberUsedFor(parserServices, context.filename)
     };
     const readListeners = classReadVisitor(classes, stack, dynamicClasses);
     const listeners = {
@@ -3389,6 +3782,10 @@ var angular = defineConfig2([
     },
     ...inlineTemplates,
     rules: {
+      // Component and directive members nothing reads (class, template, host)
+      // are dead.
+      // Bad: private unused = 1; read nowhere
+      // Good: delete it, or read it in the template
       "lint-suite-angular/no-unused-instance-fields": [
         "error",
         { analysis: "project" }
@@ -3445,8 +3842,7 @@ var baseLimits = defineConfig3([
       "**/*.ts",
       "**/*.tsx",
       "**/*.cts",
-      "**/*.mts",
-      "**/*.html"
+      "**/*.mts"
     ],
     rules: {
       "max-lines": [
@@ -3948,7 +4344,7 @@ var typescriptConsistency = defineConfig14([
     rules: {
       "@typescript-eslint/consistent-type-assertions": [
         "error",
-        { assertionStyle: "as", objectLiteralTypeAssertions: "never" }
+        { assertionStyle: "never" }
       ],
       "@typescript-eslint/consistent-type-definitions": ["error", "type"],
       "@typescript-eslint/consistent-type-imports": [
@@ -4114,71 +4510,286 @@ var typescriptRecommended = defineConfig17([
 // packages/lint-suite/src/lib/typescript-safety.ts
 import { defineConfig as defineConfig18 } from "eslint/config";
 
-// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
-import { ESLintUtils as ESLintUtils3, TSESTree as TSESTree10 } from "@typescript-eslint/utils";
-
-// packages/lint-suite/src/lib/rules/explicit-accessibility/common/explicit-accessibility.const.ts
-var accessibilities = [
-  "public",
-  "private",
-  "protected"
-];
+// packages/lint-suite/src/lib/rules/arrow-body-fits-line/arrow-body-fits-line.ts
+import { ASTUtils, ESLintUtils as ESLintUtils3, TSESTree as TSESTree10 } from "@typescript-eslint/utils";
 var docs3 = {
-  description: "Require explicit accessibility modifiers on class members"
+  description: "Require an expression-bodied arrow function to fit on one line"
 };
 var messages3 = {
-  missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected).",
-  setAccessibility: "Add the '{{ accessibility }}' modifier."
-};
-var defaultAccessibilitySchema = {
-  type: "string",
-  enum: ["public", "private", "protected", "none"],
-  description: "The accessibility modifier inserted by the auto-fix; constructors always get public. 'none' reports without an auto-fix and offers all three levels as suggestions."
-};
-var properties3 = {
-  defaultAccessibility: defaultAccessibilitySchema
-};
-var optionsSchema3 = {
-  type: "object",
-  properties: properties3,
-  additionalProperties: false
+  arrowBodyWrapped: "Expression body of this arrow function spans multiple lines; wrap it in a block with an explicit return."
 };
-var schema3 = [optionsSchema3];
+var schema3 = [];
 var meta3 = {
   type: "suggestion",
   docs: docs3,
   fixable: "code",
-  hasSuggestions: true,
   schema: schema3,
   messages: messages3
 };
-var defaultOptions3 = [{ defaultAccessibility: "public" }];
-
-// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
 var createRule3 = ESLintUtils3.RuleCreator(
-  () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
+  () => "https://github.com/F0rty-Tw0/lint-suite#arrow-body-fits-line"
 );
-var isPrivateMember = (node) => {
-  if (node.type === TSESTree10.AST_NODE_TYPES.TSParameterProperty) return false;
-  return node.key.type === TSESTree10.AST_NODE_TYPES.PrivateIdentifier;
-};
-var isConstructor = (node) => {
-  if (node.type !== TSESTree10.AST_NODE_TYPES.MethodDefinition) return false;
-  return node.kind === "constructor";
-};
-var reportTarget = (node) => {
-  if (node.type !== TSESTree10.AST_NODE_TYPES.TSParameterProperty) {
-    return node.key;
-  }
-  const { parameter } = node;
-  if (parameter.type === TSESTree10.AST_NODE_TYPES.AssignmentPattern) {
-    return parameter.left;
+var isMultiLine = (body) => body.loc.start.line !== body.loc.end.line;
+var arrowIndent = (node, sourceCode) => {
+  const line = sourceCode.lines[node.loc.start.line - 1] ?? "";
+  const leadingWhitespace = /^\s*/u.exec(line);
+  return leadingWhitespace ? leadingWhitespace[0] : "";
+};
+var wrappedBody = (indent, bodyText) => {
+  const innerIndent = `${indent}  `;
+  return `{
+${innerIndent}return ${bodyText};
+${indent}}`;
+};
+var replacementRange = (node, sourceCode) => {
+  const isParenthesized = ASTUtils.isParenthesized(node.body, sourceCode);
+  if (!isParenthesized) return node.body.range;
+  const openParen = sourceCode.getTokenBefore(node.body);
+  const closeParen = sourceCode.getTokenAfter(node.body);
+  if (!openParen || !closeParen) return node.body.range;
+  return [openParen.range[0], closeParen.range[1]];
+};
+var arrow_body_fits_line_default = createRule3({
+  name: "arrow-body-fits-line",
+  meta: meta3,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      "ArrowFunctionExpression[expression=true]"(node) {
+        const isObjectBody = node.body.type === TSESTree10.AST_NODE_TYPES.ObjectExpression;
+        if (isObjectBody) return;
+        const isMultiLineBody = isMultiLine(node.body);
+        if (!isMultiLineBody) return;
+        const indent = arrowIndent(node, sourceCode);
+        const bodyText = sourceCode.getText(node.body);
+        const range = replacementRange(node, sourceCode);
+        const fix = (fixer) => fixer.replaceTextRange(range, wrappedBody(indent, bodyText));
+        const report3 = {
+          node,
+          messageId: "arrowBodyWrapped",
+          fix
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
   }
-  return parameter;
+});
+
+// packages/lint-suite/src/lib/rules/chain-fits-line/chain-fits-line.ts
+import { ESLintUtils as ESLintUtils4, TSESTree as TSESTree11 } from "@typescript-eslint/utils";
+var docs4 = {
+  description: "Require every call in a member call chain to keep its property on the same line"
 };
-var memberName2 = (target, sourceCode) => {
-  if (target.type === TSESTree10.AST_NODE_TYPES.Identifier) return target.name;
-  return sourceCode.getText(target);
+var messages4 = {
+  chainWrapped: "Call chain is wrapped across lines; keep every call on the same line or name intermediate steps."
+};
+var meta4 = {
+  type: "suggestion",
+  docs: docs4,
+  schema: [],
+  messages: messages4
+};
+var createRule4 = ESLintUtils4.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#chain-fits-line"
+);
+var isMemberCall = (node) => {
+  if (node.type !== TSESTree11.AST_NODE_TYPES.CallExpression) return false;
+  return node.callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression;
+};
+var spinePropertyLines = (node) => {
+  const lines = [node.callee.property.loc.start.line];
+  let current = node.callee.object;
+  for (; ; ) {
+    if (isMemberCall(current)) {
+      lines.push(current.callee.property.loc.start.line);
+      current = current.callee.object;
+      continue;
+    }
+    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+      continue;
+    }
+    break;
+  }
+  return lines;
+};
+var chain_fits_line_default = createRule4({
+  name: "chain-fits-line",
+  meta: meta4,
+  defaultOptions: [],
+  create(context) {
+    const listeners = {
+      CallExpression(node) {
+        if (!isMemberCall(node)) return;
+        const isOutermost = node.parent.type !== TSESTree11.AST_NODE_TYPES.MemberExpression;
+        if (!isOutermost) return;
+        const lines = spinePropertyLines(node);
+        if (lines.length < 2) return;
+        const isWrapped = new Set(lines).size > 1;
+        if (!isWrapped) return;
+        const report3 = {
+          node,
+          messageId: "chainWrapped"
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/chain-receiver-is-name/chain-receiver-is-name.ts
+import { ESLintUtils as ESLintUtils5, TSESTree as TSESTree12 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/utils/indent-of.util.ts
+var indentOf = (node, sourceCode) => {
+  const line = sourceCode.lines[node.loc.start.line - 1] ?? "";
+  const [leading] = /^[ \t]*/.exec(line) ?? [""];
+  return leading;
+};
+
+// packages/lint-suite/src/lib/rules/chain-receiver-is-name/chain-receiver-is-name.ts
+var docs5 = {
+  description: "Require a call chain to start from a name, not an inline expression"
+};
+var messages5 = {
+  chainReceiver: "Call chain starts from an inline expression; extract it to a named constant first.",
+  extractReceiver: "Extract the receiver to a 'value' constant."
+};
+var meta5 = {
+  type: "suggestion",
+  docs: docs5,
+  hasSuggestions: true,
+  schema: [],
+  messages: messages5
+};
+var createRule5 = ESLintUtils5.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#chain-receiver-is-name"
+);
+var UNNAMED_RECEIVER_TYPES = /* @__PURE__ */ new Set([
+  TSESTree12.AST_NODE_TYPES.LogicalExpression,
+  TSESTree12.AST_NODE_TYPES.ConditionalExpression,
+  TSESTree12.AST_NODE_TYPES.ObjectExpression,
+  TSESTree12.AST_NODE_TYPES.ArrayExpression,
+  TSESTree12.AST_NODE_TYPES.AwaitExpression,
+  TSESTree12.AST_NODE_TYPES.BinaryExpression,
+  TSESTree12.AST_NODE_TYPES.TemplateLiteral
+]);
+var enclosingStatement = (node) => {
+  let current = node;
+  while (current.parent.type !== TSESTree12.AST_NODE_TYPES.BlockStatement && current.parent.type !== TSESTree12.AST_NODE_TYPES.Program) {
+    current = current.parent;
+  }
+  return current;
+};
+var suggestionOf = (node, sourceCode) => {
+  const statement = enclosingStatement(node);
+  const indent = indentOf(statement, sourceCode);
+  const objectText = sourceCode.getText(node.object);
+  const declaration = `const value = ${objectText};
+${indent}`;
+  const fix = (fixer) => {
+    const hoisted = fixer.insertTextBefore(statement, declaration);
+    const replaced = fixer.replaceText(node.object, "value");
+    const fixes = [hoisted, replaced];
+    return fixes;
+  };
+  const suggestion = {
+    messageId: "extractReceiver",
+    fix
+  };
+  return suggestion;
+};
+var chain_receiver_is_name_default = createRule5({
+  name: "chain-receiver-is-name",
+  meta: meta5,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      MemberExpression(node) {
+        const isUnnamedReceiver = UNNAMED_RECEIVER_TYPES.has(node.object.type);
+        if (!isUnnamedReceiver) return;
+        const suggest = [suggestionOf(node, sourceCode)];
+        const report3 = {
+          node,
+          messageId: "chainReceiver",
+          suggest
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
+import { ESLintUtils as ESLintUtils6, TSESTree as TSESTree13 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/common/explicit-accessibility.const.ts
+var accessibilities = [
+  "public",
+  "private",
+  "protected"
+];
+var docs6 = {
+  description: "Require explicit accessibility modifiers on class members"
+};
+var messages6 = {
+  missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected).",
+  setAccessibility: "Add the '{{ accessibility }}' modifier."
+};
+var defaultAccessibilitySchema = {
+  type: "string",
+  enum: ["public", "private", "protected", "none"],
+  description: "The accessibility modifier inserted by the auto-fix; constructors always get public. 'none' reports without an auto-fix and offers all three levels as suggestions."
+};
+var properties3 = {
+  defaultAccessibility: defaultAccessibilitySchema
+};
+var optionsSchema3 = {
+  type: "object",
+  properties: properties3,
+  additionalProperties: false
+};
+var schema4 = [optionsSchema3];
+var meta6 = {
+  type: "suggestion",
+  docs: docs6,
+  fixable: "code",
+  hasSuggestions: true,
+  schema: schema4,
+  messages: messages6
+};
+var defaultOptions3 = [{ defaultAccessibility: "public" }];
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
+var createRule6 = ESLintUtils6.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
+);
+var isPrivateMember = (node) => {
+  if (node.type === TSESTree13.AST_NODE_TYPES.TSParameterProperty) return false;
+  return node.key.type === TSESTree13.AST_NODE_TYPES.PrivateIdentifier;
+};
+var isConstructor = (node) => {
+  if (node.type !== TSESTree13.AST_NODE_TYPES.MethodDefinition) return false;
+  return node.kind === "constructor";
+};
+var reportTarget = (node) => {
+  if (node.type !== TSESTree13.AST_NODE_TYPES.TSParameterProperty) {
+    return node.key;
+  }
+  const { parameter } = node;
+  if (parameter.type === TSESTree13.AST_NODE_TYPES.AssignmentPattern) {
+    return parameter.left;
+  }
+  return parameter;
+};
+var memberName2 = (target, sourceCode) => {
+  if (target.type === TSESTree13.AST_NODE_TYPES.Identifier) return target.name;
+  return sourceCode.getText(target);
 };
 var modifierToken = (node, sourceCode) => {
   const lastDecorator = node.decorators.at(-1);
@@ -4202,7 +4813,7 @@ var autoFixOf = (node, accessibility, sourceCode) => {
   const autoFix = { fix };
   return autoFix;
 };
-var suggestionOf = (node, accessibility, sourceCode) => {
+var suggestionOf2 = (node, accessibility, sourceCode) => {
   const data = { accessibility };
   const fix = insertModifier(node, accessibility, sourceCode);
   const suggestion = {
@@ -4216,93 +4827,1602 @@ var suggestionsOf = (node, fixAccessibility, sourceCode) => {
   const isOtherAccessibility = (accessibility) => {
     return accessibility !== fixAccessibility;
   };
-  const suggestionFor = (accessibility) => {
-    return suggestionOf(node, accessibility, sourceCode);
+  const suggestionFor2 = (accessibility) => {
+    return suggestionOf2(node, accessibility, sourceCode);
+  };
+  return accessibilities.filter(isOtherAccessibility).map(suggestionFor2);
+};
+var explicit_accessibility_default = createRule6({
+  name: "explicit-accessibility",
+  meta: meta6,
+  defaultOptions: defaultOptions3,
+  create(context, [{ defaultAccessibility = "public" }]) {
+    const { sourceCode } = context;
+    const check = (node) => {
+      const isPrivate = isPrivateMember(node);
+      if (node.accessibility || isPrivate) return;
+      const target = reportTarget(node);
+      const isConstructorMember = isConstructor(node);
+      const usesPublic = isConstructorMember && defaultAccessibility !== "none";
+      const fixAccessibility = usesPublic ? "public" : defaultAccessibility;
+      const autoFix = autoFixOf(node, fixAccessibility, sourceCode);
+      const name = memberName2(target, sourceCode);
+      const data = { name };
+      const suggest = suggestionsOf(node, fixAccessibility, sourceCode);
+      const report3 = {
+        node: target,
+        messageId: "missingAccessibility",
+        data,
+        ...autoFix,
+        suggest
+      };
+      context.report(report3);
+    };
+    const listeners = {
+      AccessorProperty: check,
+      MethodDefinition: check,
+      PropertyDefinition: check,
+      TSAbstractAccessorProperty: check,
+      TSAbstractMethodDefinition: check,
+      TSAbstractPropertyDefinition: check,
+      TSParameterProperty: check
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/max-condition-operands/max-condition-operands.ts
+import { ESLintUtils as ESLintUtils7, TSESTree as TSESTree14 } from "@typescript-eslint/utils";
+var docs7 = {
+  description: "Limit the number of operands in an if statement condition to keep it readable"
+};
+var messages7 = {
+  tooManyOperands: "This condition has {{ count }} operands; extract it into a named const when it exceeds {{ max }}."
+};
+var maxSchema = { type: "integer", minimum: 1 };
+var properties4 = {
+  max: maxSchema
+};
+var optionsSchema4 = {
+  type: "object",
+  properties: properties4,
+  additionalProperties: false
+};
+var schema5 = [optionsSchema4];
+var meta7 = {
+  type: "suggestion",
+  docs: docs7,
+  schema: schema5,
+  messages: messages7
+};
+var createRule7 = ESLintUtils7.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#max-condition-operands"
+);
+var countOperands = (node) => {
+  if (node.type !== TSESTree14.AST_NODE_TYPES.LogicalExpression) return 1;
+  return countOperands(node.left) + countOperands(node.right);
+};
+var defaultOptions4 = [{ max: 3 }];
+var max_condition_operands_default = createRule7({
+  name: "max-condition-operands",
+  meta: meta7,
+  defaultOptions: defaultOptions4,
+  create(context, [{ max }]) {
+    const listeners = {
+      IfStatement(node) {
+        const count = countOperands(node.test);
+        if (count <= max) return;
+        const data = { count, max };
+        const report3 = {
+          node: node.test,
+          messageId: "tooManyOperands",
+          data
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/no-call-in-condition.ts
+import { ESLintUtils as ESLintUtils8, TSESTree as TSESTree17 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/common/no-call-in-condition.const.ts
+var PREDICATE_PATTERNS = ["^(is|has)[A-Z]"];
+var docs8 = {
+  description: "Disallow a function call inside an if condition or a boolean const that feeds one"
+};
+var messages8 = {
+  callInCondition: "Call '{{ callee }}' decides inside a condition; assign it to a named const first.",
+  hoistCall: "Assign the call to '{{ name }}' above the statement."
+};
+var patternSchema = { type: "string" };
+var allowPredicatesSchema = {
+  type: "array",
+  items: patternSchema,
+  description: "Regular expression sources for callee names treated as type predicates when no TypeScript program is available."
+};
+var properties5 = {
+  allowPredicates: allowPredicatesSchema
+};
+var optionsSchema5 = {
+  type: "object",
+  properties: properties5,
+  additionalProperties: false
+};
+var schema6 = [optionsSchema5];
+var meta8 = {
+  type: "suggestion",
+  docs: docs8,
+  hasSuggestions: true,
+  schema: schema6,
+  messages: messages8
+};
+var ruleDefaults3 = {
+  allowPredicates: PREDICATE_PATTERNS
+};
+var defaultOptions5 = [ruleDefaults3];
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/utils/call-exemptions.util.ts
+import { ASTUtils as ASTUtils3, TSESTree as TSESTree16 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/utils/condition-calls.util.ts
+import { ASTUtils as ASTUtils2, TSESTree as TSESTree15 } from "@typescript-eslint/utils";
+var collectParts = (node, parts) => {
+  if (node.type === TSESTree15.AST_NODE_TYPES.CallExpression) {
+    parts.calls.push(node);
+    return;
+  }
+  if (node.type === TSESTree15.AST_NODE_TYPES.Identifier) {
+    parts.identifiers.push(node);
+    return;
+  }
+  if (node.type === TSESTree15.AST_NODE_TYPES.UnaryExpression) {
+    collectParts(node.argument, parts);
+    return;
+  }
+  const isLogical = node.type === TSESTree15.AST_NODE_TYPES.LogicalExpression;
+  const isBinary = node.type === TSESTree15.AST_NODE_TYPES.BinaryExpression;
+  if (!isLogical && !isBinary) return;
+  collectParts(node.left, parts);
+  collectParts(node.right, parts);
+};
+var conditionParts = (node) => {
+  const parts = { calls: [], identifiers: [] };
+  collectParts(node, parts);
+  return parts;
+};
+var calleeName = (callee) => {
+  if (callee.type === TSESTree15.AST_NODE_TYPES.Identifier) return callee.name;
+  if (callee.type !== TSESTree15.AST_NODE_TYPES.MemberExpression) {
+    return void 0;
+  }
+  const { property } = callee;
+  if (property.type !== TSESTree15.AST_NODE_TYPES.Identifier) return void 0;
+  return property.name;
+};
+var constFeed = (identifier, scope) => {
+  const variable = ASTUtils2.findVariable(scope, identifier);
+  if (variable?.defs.length !== 1) return void 0;
+  const definition = variable.defs.at(0);
+  if (!definition) return void 0;
+  const declaration = definition.parent;
+  if (declaration?.type !== TSESTree15.AST_NODE_TYPES.VariableDeclaration) {
+    return void 0;
+  }
+  if (declaration.kind !== "const") return void 0;
+  const { node } = definition;
+  if (node.type !== TSESTree15.AST_NODE_TYPES.VariableDeclarator) {
+    return void 0;
+  }
+  const { init } = node;
+  if (!init) return void 0;
+  if (init.type === TSESTree15.AST_NODE_TYPES.CallExpression) return void 0;
+  const feed = { init, statement: declaration };
+  return feed;
+};
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/utils/call-exemptions.util.ts
+var PREDICATE_HOLDERS = [
+  TSESTree16.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree16.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree16.AST_NODE_TYPES.FunctionExpression,
+  TSESTree16.AST_NODE_TYPES.TSDeclareFunction
+];
+var isPredicateHolder = ASTUtils3.isNodeOfTypes(PREDICATE_HOLDERS);
+var hasPredicateReturn = (node) => {
+  if (!isPredicateHolder(node)) return false;
+  const returned = node.returnType?.typeAnnotation.type;
+  return returned === TSESTree16.AST_NODE_TYPES.TSTypePredicate;
+};
+var declaredFunction = (definition) => {
+  const { node } = definition;
+  if (node.type !== TSESTree16.AST_NODE_TYPES.VariableDeclarator) return node;
+  return node.init ?? void 0;
+};
+var isThisSignalRead = (call) => {
+  if (call.arguments.length > 0) return false;
+  const { callee } = call;
+  if (callee.type !== TSESTree16.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.computed) return false;
+  return callee.object.type === TSESTree16.AST_NODE_TYPES.ThisExpression;
+};
+var isScopePredicate = (callee, scope) => {
+  if (callee.type !== TSESTree16.AST_NODE_TYPES.Identifier) return false;
+  const variable = ASTUtils3.findVariable(scope, callee);
+  const definition = variable?.defs.at(0);
+  if (!definition) return false;
+  const declaration = declaredFunction(definition);
+  if (!declaration) return false;
+  return hasPredicateReturn(declaration);
+};
+var isCheckerPredicate = (callee, services) => {
+  const checker = services.program.getTypeChecker();
+  const calleeType = services.getTypeAtLocation(callee);
+  const signatures = calleeType.getCallSignatures();
+  const isPredicateSignature = (signature) => {
+    const predicate = checker.getTypePredicateOfSignature(signature);
+    return predicate !== void 0;
+  };
+  return signatures.some(isPredicateSignature);
+};
+var isAllowedName = (callee, allowed) => {
+  const name = calleeName(callee);
+  if (name === void 0) return false;
+  return allowed.some((pattern) => pattern.test(name));
+};
+var isExemptCall = (call, exemptions) => {
+  const isSignalRead = isThisSignalRead(call);
+  if (isSignalRead) return true;
+  const { allowed, scope, services } = exemptions;
+  const { callee } = call;
+  const isDeclaredPredicate = isScopePredicate(callee, scope);
+  if (isDeclaredPredicate) return true;
+  if (services) return isCheckerPredicate(callee, services);
+  return isAllowedName(callee, allowed);
+};
+
+// packages/lint-suite/src/lib/rules/no-call-in-condition/no-call-in-condition.ts
+var createRule8 = ESLintUtils8.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-call-in-condition"
+);
+var HOISTABLE_PARENTS = /* @__PURE__ */ new Set([
+  TSESTree17.AST_NODE_TYPES.BlockStatement,
+  TSESTree17.AST_NODE_TYPES.Program,
+  TSESTree17.AST_NODE_TYPES.StaticBlock,
+  TSESTree17.AST_NODE_TYPES.SwitchCase,
+  TSESTree17.AST_NODE_TYPES.TSModuleBlock
+]);
+var INDENT_PATTERN = /^[\t ]*/u;
+var typedServices = (context) => {
+  const { parserServices } = context.sourceCode;
+  if (!parserServices?.program) return void 0;
+  return ESLintUtils8.getParserServices(context);
+};
+var statementIndent = (statement, sourceCode) => {
+  const line = sourceCode.lines[statement.loc.start.line - 1] ?? "";
+  const indent = INDENT_PATTERN.exec(line)?.[0];
+  return indent ?? "";
+};
+var suggestionsOf2 = (call, statement, sourceCode) => {
+  const empty = [];
+  const isHoistable = HOISTABLE_PARENTS.has(statement.parent.type);
+  if (!isHoistable) return empty;
+  const name = calleeName(call.callee);
+  if (name === void 0) return empty;
+  const constName = `${name}Result`;
+  const callText = sourceCode.getText(call);
+  const indent = statementIndent(statement, sourceCode);
+  const declaration = `const ${constName} = ${callText};
+${indent}`;
+  const fix = (fixer) => {
+    const hoisted = fixer.insertTextBefore(statement, declaration);
+    const replaced = fixer.replaceText(call, constName);
+    const fixes = [hoisted, replaced];
+    return fixes;
+  };
+  const data = { name: constName };
+  const suggestion = {
+    messageId: "hoistCall",
+    data,
+    fix
+  };
+  const suggestions = [suggestion];
+  return suggestions;
+};
+var reportOf = (call, statement, sourceCode) => {
+  const suggest = suggestionsOf2(call, statement, sourceCode);
+  const callee = sourceCode.getText(call.callee);
+  const data = { callee };
+  const report3 = {
+    node: call,
+    messageId: "callInCondition",
+    data,
+    suggest
+  };
+  return report3;
+};
+var no_call_in_condition_default = createRule8({
+  name: "no-call-in-condition",
+  meta: meta8,
+  defaultOptions: defaultOptions5,
+  create(context, [{ allowPredicates = PREDICATE_PATTERNS }]) {
+    const { sourceCode } = context;
+    const services = typedServices(context);
+    const allowed = allowPredicates.map(toRegExp);
+    const reported = /* @__PURE__ */ new Set();
+    const reportCalls = (calls, statement, exemptions) => {
+      for (const call of calls) {
+        const isReported = reported.has(call);
+        if (isReported) continue;
+        const isExempt = isExemptCall(call, exemptions);
+        if (isExempt) continue;
+        reported.add(call);
+        const report3 = reportOf(call, statement, sourceCode);
+        context.report(report3);
+      }
+    };
+    const listeners = {
+      IfStatement(node) {
+        const { calls, identifiers } = conditionParts(node.test);
+        const isEmpty = calls.length === 0 && identifiers.length === 0;
+        if (isEmpty) return;
+        const scope = sourceCode.getScope(node);
+        const exemptions = { allowed, scope, services };
+        reportCalls(calls, node, exemptions);
+        for (const identifier of identifiers) {
+          const feed = constFeed(identifier, scope);
+          if (feed) {
+            const fed = conditionParts(feed.init);
+            reportCalls(fed.calls, feed.statement, exemptions);
+          }
+        }
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-grouped-condition/no-grouped-condition.ts
+import { ESLintUtils as ESLintUtils9, TSESTree as TSESTree18 } from "@typescript-eslint/utils";
+var docs9 = {
+  description: "Require a mixed-operator group inside a logical condition to be hoisted into a named const"
+};
+var messages9 = {
+  groupedCondition: "This group mixes a different operator than its enclosing condition; hoist it into a named const.",
+  hoistGroup: "Extract the group into a named const."
+};
+var meta9 = {
+  type: "suggestion",
+  docs: docs9,
+  hasSuggestions: true,
+  schema: [],
+  messages: messages9
+};
+var createRule9 = ESLintUtils9.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-grouped-condition"
+);
+var GROUP_NAME = "isGroup";
+var outermostLogical = (node) => {
+  let current = node;
+  while (current.parent.type === TSESTree18.AST_NODE_TYPES.LogicalExpression) {
+    current = current.parent;
+  }
+  return current;
+};
+var reportRootOf = (node) => {
+  const outermost = outermostLogical(node);
+  const { parent } = outermost;
+  if (parent.type === TSESTree18.AST_NODE_TYPES.IfStatement) {
+    if (parent.test !== outermost) return void 0;
+    const reportRoot2 = { statement: parent };
+    return reportRoot2;
+  }
+  if (parent.type !== TSESTree18.AST_NODE_TYPES.VariableDeclarator) {
+    return void 0;
+  }
+  const isConstInit = parent.init === outermost && parent.parent.kind === "const";
+  if (!isConstInit) return void 0;
+  const reportRoot = { statement: parent.parent };
+  return reportRoot;
+};
+var suggestionFor = (node, statement, sourceCode) => {
+  const groupText = sourceCode.getText(node);
+  const line = sourceCode.lines[statement.loc.start.line - 1] ?? "";
+  const indent = line.slice(0, statement.loc.start.column);
+  const declaration = `const ${GROUP_NAME} = ${groupText};
+${indent}`;
+  const fix = (fixer) => {
+    const hoisted = fixer.insertTextBefore(statement, declaration);
+    const replaced = fixer.replaceText(node, GROUP_NAME);
+    const fixes = [hoisted, replaced];
+    return fixes;
+  };
+  const suggestion = {
+    messageId: "hoistGroup",
+    fix
+  };
+  return suggestion;
+};
+var no_grouped_condition_default = createRule9({
+  name: "no-grouped-condition",
+  meta: meta9,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      "LogicalExpression > LogicalExpression"(node) {
+        const { parent } = node;
+        if (parent.type !== TSESTree18.AST_NODE_TYPES.LogicalExpression) return;
+        const hasSameOperator = node.operator === parent.operator;
+        if (hasSameOperator) return;
+        const reportRoot = reportRootOf(node);
+        if (!reportRoot) return;
+        const suggestion = suggestionFor(
+          node,
+          reportRoot.statement,
+          sourceCode
+        );
+        const report3 = {
+          node,
+          messageId: "groupedCondition",
+          suggest: [suggestion]
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-inline-object-types/no-inline-object-types.ts
+import { ESLintUtils as ESLintUtils10, TSESTree as TSESTree19 } from "@typescript-eslint/utils";
+var docs10 = {
+  description: "Require every object type literal to be the body of a named type alias"
+};
+var messages10 = {
+  inlineObjectType: "Object type literal must be the body of a named type alias."
+};
+var meta10 = {
+  type: "suggestion",
+  docs: docs10,
+  schema: [],
+  messages: messages10
+};
+var createRule10 = ESLintUtils10.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
+);
+var no_inline_object_types_default = createRule10({
+  name: "no-inline-object-types",
+  meta: meta10,
+  defaultOptions: [],
+  create(context) {
+    const listeners = {
+      TSTypeLiteral(node) {
+        const isAliasBody = node.parent.type === TSESTree19.AST_NODE_TYPES.TSTypeAliasDeclaration;
+        if (isAliasBody) return;
+        const report3 = {
+          node,
+          messageId: "inlineObjectType"
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-inline-return-object/no-inline-return-object.ts
+import { ESLintUtils as ESLintUtils11, TSESTree as TSESTree20 } from "@typescript-eslint/utils";
+var docs11 = {
+  description: "Require an inline returned object literal to be named as a constant first"
+};
+var messages11 = {
+  inlineReturnObject: "Object literal is returned inline; name it as a constant first."
+};
+var meta11 = {
+  type: "suggestion",
+  docs: docs11,
+  hasSuggestions: true,
+  schema: [],
+  messages: messages11
+};
+var createRule11 = ESLintUtils11.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-return-object"
+);
+var wrappingRange = (objectExpression, sourceCode) => {
+  const before = sourceCode.getTokenBefore(objectExpression);
+  const after = sourceCode.getTokenAfter(objectExpression);
+  const isWrapped = before?.value === "(" && after?.value === ")";
+  if (!isWrapped) return objectExpression.range;
+  return [before.range[0], after.range[1]];
+};
+var returnSuggestion = (node, objectExpression, sourceCode) => {
+  const indent = indentOf(node, sourceCode);
+  const objectText = sourceCode.getText(objectExpression);
+  const fix = (fixer) => {
+    const declaration = fixer.insertTextBefore(
+      node,
+      `const result = ${objectText};
+
+${indent}`
+    );
+    const replaced = fixer.replaceText(objectExpression, "result");
+    const fixes = [declaration, replaced];
+    return fixes;
+  };
+  const suggestion = {
+    messageId: "inlineReturnObject",
+    fix
+  };
+  return suggestion;
+};
+var arrowSuggestion = (node, objectExpression, sourceCode) => {
+  const indent = indentOf(node, sourceCode);
+  const bodyIndent = `${indent}  `;
+  const objectText = sourceCode.getText(objectExpression);
+  const replacement = `{
+${bodyIndent}const result = ${objectText};
+
+${bodyIndent}return result;
+${indent}}`;
+  const range = wrappingRange(objectExpression, sourceCode);
+  const fix = (fixer) => fixer.replaceTextRange(range, replacement);
+  const suggestion = {
+    messageId: "inlineReturnObject",
+    fix
+  };
+  return suggestion;
+};
+var no_inline_return_object_default = createRule11({
+  name: "no-inline-return-object",
+  meta: meta11,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      ReturnStatement(node) {
+        if (node.argument?.type !== TSESTree20.AST_NODE_TYPES.ObjectExpression) {
+          return;
+        }
+        const objectExpression = node.argument;
+        const suggest = [returnSuggestion(node, objectExpression, sourceCode)];
+        const report3 = {
+          node,
+          messageId: "inlineReturnObject",
+          suggest
+        };
+        context.report(report3);
+      },
+      ArrowFunctionExpression(node) {
+        if (!node.expression) return;
+        if (node.body.type !== TSESTree20.AST_NODE_TYPES.ObjectExpression) return;
+        const objectExpression = node.body;
+        const suggest = [arrowSuggestion(node, objectExpression, sourceCode)];
+        const report3 = {
+          node,
+          messageId: "inlineReturnObject",
+          suggest
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-nested-object-value/no-nested-object-value.ts
+import { ESLintUtils as ESLintUtils12, TSESTree as TSESTree23 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/utils/glob-matcher.util.ts
+var GLOB_TOKEN = /\*\*\/|\*\*|\*|\?|\{[^}]*\}|[^*?{]+/gu;
+var REGEXP_ESCAPE = /[.*+?^${}()|[\]\\]/gu;
+var escapeLiteral = (value) => value.replaceAll(REGEXP_ESCAPE, "\\$&");
+var braceAlternatives = (token) => {
+  const inner = token.slice(1, -1);
+  const alternatives = inner.split(",").map(escapeLiteral);
+  return `(?:${alternatives.join("|")})`;
+};
+var translateToken = (token) => {
+  if (token === "**/") return "(?:.*/)?";
+  if (token === "**") return ".*";
+  if (token === "*") return "[^/]*";
+  if (token === "?") return "[^/]";
+  const startsWithBrace = token.startsWith("{");
+  const endsWithBrace = token.endsWith("}");
+  if (startsWithBrace && endsWithBrace) return braceAlternatives(token);
+  return escapeLiteral(token);
+};
+var globSource = (pattern) => {
+  const tokens = pattern.match(GLOB_TOKEN) ?? [];
+  return tokens.map(translateToken).join("");
+};
+var ALL_DEPTH_PREFIX = "**/";
+var ALL_DEPTH_GROUP = "(?:.*/)?";
+var stripAllDepthPrefix = (pattern) => {
+  const hasPrefix = pattern.startsWith(ALL_DEPTH_PREFIX);
+  if (!hasPrefix) return pattern;
+  return pattern.slice(ALL_DEPTH_PREFIX.length);
+};
+var sharesAllDepthPrefix = (patterns) => patterns.every((pattern) => pattern.startsWith(ALL_DEPTH_PREFIX));
+var combinedSource = (patterns) => {
+  const hoistPrefix = sharesAllDepthPrefix(patterns);
+  if (!hoistPrefix) {
+    const sources2 = patterns.map(globSource);
+    return `(?:${sources2.join("|")})`;
+  }
+  const bodies = patterns.map(stripAllDepthPrefix);
+  const sources = bodies.map(globSource);
+  return `${ALL_DEPTH_GROUP}(?:${sources.join("|")})`;
+};
+var compileGlobs = (patterns) => {
+  const source = combinedSource(patterns);
+  const combined = new RegExp(`^${source}$`, "u");
+  const matchPath = (path) => {
+    const normalised = path.replaceAll("\\", "/");
+    return combined.test(normalised);
+  };
+  return matchPath;
+};
+
+// packages/lint-suite/src/lib/rules/no-nested-object-value/common/no-nested-object-value.const.ts
+var DEFAULT_CONFIG_FILES = [
+  "**/*.config.{ts,js,mjs,cjs}",
+  "**/eslint.config.*",
+  "**/*.schema.ts"
+];
+var docs12 = {
+  description: "Require a nested object literal, array of objects, conditional, or chained call used as a property value to be named as a constant first"
+};
+var messages12 = {
+  nestedValue: "Property '{{ key }}' holds a nested value inline; name it as a constant first."
+};
+var configFilesItemsSchema = { type: "string" };
+var configFilesSchema = {
+  type: "array",
+  items: configFilesItemsSchema
+};
+var properties6 = {
+  configFiles: configFilesSchema
+};
+var optionsSchema6 = {
+  type: "object",
+  properties: properties6,
+  additionalProperties: false
+};
+var schema7 = [optionsSchema6];
+var meta12 = {
+  type: "suggestion",
+  docs: docs12,
+  hasSuggestions: true,
+  schema: schema7,
+  messages: messages12
+};
+var defaultOptions6 = [{ configFiles: DEFAULT_CONFIG_FILES }];
+
+// packages/lint-suite/src/lib/rules/no-nested-object-value/utils/decorator-config.util.ts
+import { TSESTree as TSESTree21 } from "@typescript-eslint/utils";
+var MAX_DECORATOR_OBJECT_HOPS = 3;
+var isDecoratorArgument = (node) => {
+  const { parent } = node;
+  if (parent.type !== TSESTree21.AST_NODE_TYPES.CallExpression) return false;
+  const { parent: grandparent } = parent;
+  return grandparent.type === TSESTree21.AST_NODE_TYPES.Decorator;
+};
+var isInsideDecoratorConfig = (objectExpression, ancestors) => {
+  let objectHops = 0;
+  const isDecoratorConfig = isDecoratorArgument(objectExpression);
+  if (isDecoratorConfig) return true;
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const ancestor = ancestors[index];
+    if (ancestor?.type !== TSESTree21.AST_NODE_TYPES.ObjectExpression) continue;
+    objectHops += 1;
+    const isAncestorDecoratorConfig = isDecoratorArgument(ancestor);
+    if (isAncestorDecoratorConfig) return true;
+    if (objectHops >= MAX_DECORATOR_OBJECT_HOPS) return false;
+  }
+  return false;
+};
+
+// packages/lint-suite/src/lib/rules/utils/enclosing-statement.util.ts
+import { TSESTree as TSESTree22 } from "@typescript-eslint/utils";
+var isBodyContainer = (node) => {
+  return node.type === TSESTree22.AST_NODE_TYPES.Program || node.type === TSESTree22.AST_NODE_TYPES.BlockStatement || node.type === TSESTree22.AST_NODE_TYPES.StaticBlock;
+};
+var enclosingStatement2 = (node) => {
+  let current = node;
+  for (; ; ) {
+    const { parent } = current;
+    if (!parent || isBodyContainer(parent)) return current;
+    current = parent;
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-nested-object-value/no-nested-object-value.ts
+var createRule12 = ESLintUtils12.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-nested-object-value"
+);
+var isChainedCall = (node) => {
+  const { callee } = node;
+  if (callee.type !== TSESTree23.AST_NODE_TYPES.MemberExpression) return false;
+  return callee.object.type === TSESTree23.AST_NODE_TYPES.CallExpression;
+};
+var isObjectElement = (element) => {
+  return element?.type === TSESTree23.AST_NODE_TYPES.ObjectExpression;
+};
+var hasNestedObjectElement = (node) => {
+  return node.elements.some(isObjectElement);
+};
+var isNestedValue = (value) => {
+  if (value.type === TSESTree23.AST_NODE_TYPES.ObjectExpression) {
+    return value.properties.length > 0;
+  }
+  if (value.type === TSESTree23.AST_NODE_TYPES.ArrayExpression) {
+    return hasNestedObjectElement(value);
+  }
+  if (value.type === TSESTree23.AST_NODE_TYPES.ConditionalExpression) return true;
+  if (value.type === TSESTree23.AST_NODE_TYPES.CallExpression) {
+    return isChainedCall(value);
+  }
+  return false;
+};
+var CONFIG_FILE_MATCHERS = /* @__PURE__ */ new WeakMap();
+var configFileMatcher = (configFiles) => {
+  const cached = CONFIG_FILE_MATCHERS.get(configFiles);
+  if (cached) return cached;
+  const matcher = compileGlobs(configFiles);
+  CONFIG_FILE_MATCHERS.set(configFiles, matcher);
+  return matcher;
+};
+var isConfigFile = (filename, configFiles) => {
+  const matchesConfig = configFileMatcher(configFiles);
+  return matchesConfig(filename);
+};
+var suggestionsFor = (property, key2, sourceCode) => {
+  const empty = [];
+  const isNamedKey = property.key.type === TSESTree23.AST_NODE_TYPES.Identifier && !property.computed;
+  if (!isNamedKey) return empty;
+  const statement = enclosingStatement2(property);
+  const indent = indentOf(statement, sourceCode);
+  const valueText = sourceCode.getText(property.value);
+  const fix = (fixer) => {
+    const declaration = fixer.insertTextBefore(
+      statement,
+      `const ${key2} = ${valueText};
+${indent}`
+    );
+    const replaced = fixer.replaceText(property.value, key2);
+    const fixes = [declaration, replaced];
+    return fixes;
+  };
+  const data = { key: key2 };
+  const suggestion = {
+    messageId: "nestedValue",
+    data,
+    fix
+  };
+  const suggestions = [
+    suggestion
+  ];
+  return suggestions;
+};
+var no_nested_object_value_default = createRule12({
+  name: "no-nested-object-value",
+  meta: meta12,
+  defaultOptions: defaultOptions6,
+  create(context, [{ configFiles }]) {
+    const isExemptFile2 = isConfigFile(context.filename, configFiles);
+    if (isExemptFile2) {
+      const noListeners = {};
+      return noListeners;
+    }
+    const { sourceCode } = context;
+    const listeners = {
+      Property(node) {
+        if (node.parent.type !== TSESTree23.AST_NODE_TYPES.ObjectExpression)
+          return;
+        const isNested = isNestedValue(node.value);
+        if (!isNested) return;
+        const ancestors = sourceCode.getAncestors(node.parent);
+        const isDecoratorConfig = isInsideDecoratorConfig(
+          node.parent,
+          ancestors
+        );
+        if (isDecoratorConfig) return;
+        const key2 = sourceCode.getText(node.key);
+        const suggest = suggestionsFor(node, key2, sourceCode);
+        const data = { key: key2 };
+        const report3 = {
+          node,
+          messageId: "nestedValue",
+          data,
+          suggest
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-spread-expression/no-spread-expression.ts
+import { ESLintUtils as ESLintUtils13, TSESTree as TSESTree24 } from "@typescript-eslint/utils";
+var docs13 = {
+  description: "Require a spread argument to be an identifier or member access, not an inline expression"
+};
+var messages13 = {
+  spreadExpression: "Spread argument is an inline expression; name it as a constant first."
+};
+var meta13 = {
+  type: "suggestion",
+  docs: docs13,
+  hasSuggestions: true,
+  schema: [],
+  messages: messages13
+};
+var createRule13 = ESLintUtils13.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-spread-expression"
+);
+var ALLOWED_ARGUMENT_TYPES = /* @__PURE__ */ new Set([
+  TSESTree24.AST_NODE_TYPES.Identifier,
+  TSESTree24.AST_NODE_TYPES.MemberExpression
+]);
+var no_spread_expression_default = createRule13({
+  name: "no-spread-expression",
+  meta: meta13,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      SpreadElement(node) {
+        const isAllowed = ALLOWED_ARGUMENT_TYPES.has(node.argument.type);
+        if (isAllowed) return;
+        const statement = enclosingStatement2(node);
+        const indent = indentOf(statement, sourceCode);
+        const argumentText = sourceCode.getText(node.argument);
+        const fix = (fixer) => {
+          const declaration = fixer.insertTextBefore(
+            statement,
+            `const spread = ${argumentText};
+${indent}`
+          );
+          const replaced = fixer.replaceText(node.argument, "spread");
+          const fixes = [declaration, replaced];
+          return fixes;
+        };
+        const suggestion = {
+          messageId: "spreadExpression",
+          fix
+        };
+        const report3 = {
+          node,
+          messageId: "spreadExpression",
+          suggest: [suggestion]
+        };
+        context.report(report3);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/no-unused-exports.ts
+import { ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/common/no-unused-exports.const.ts
+var entryPointDefaults = [
+  "**/main.ts",
+  "**/main.*.ts",
+  "**/public-api.ts",
+  "**/index.ts",
+  "**/*.config.ts",
+  "**/*.config.mts",
+  "**/*.config.cts",
+  "**/*.spec.ts",
+  "**/*.spec.util.ts",
+  "**/*.stub.ts",
+  "**/*.mock.ts",
+  "**/*.d.ts",
+  "**/*.stories.ts",
+  "**/environment*.ts"
+];
+var STAR_NAME = "*";
+var docs14 = {
+  description: "Disallow exports that no other file in the TypeScript program imports"
+};
+var messages14 = {
+  unusedExport: "Export '{{ name }}' is never imported by another file.",
+  unusedModule: "This module exports names but is never imported."
+};
+var entryPointItemsSchema = { type: "string" };
+var entryPointsSchema = {
+  type: "array",
+  items: entryPointItemsSchema,
+  description: "Globs whose files are treated as project entry points."
+};
+var properties7 = {
+  entryPoints: entryPointsSchema
+};
+var optionsSchema7 = {
+  type: "object",
+  properties: properties7,
+  additionalProperties: false
+};
+var schema8 = [optionsSchema7];
+var meta14 = {
+  type: "problem",
+  docs: docs14,
+  schema: schema8,
+  messages: messages14
+};
+var ruleDefaults4 = { entryPoints: [...entryPointDefaults] };
+var defaultOptions7 = [ruleDefaults4];
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/export-index.ts
+import { dirname as dirname10 } from "node:path";
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/export-usage.util.ts
+var MAX_DEPTH = 50;
+var reExportIndex = (byFile) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const [fileName, edges] of byFile) {
+    const names = /* @__PURE__ */ new Map();
+    for (const edge of edges.reExports) {
+      names.set(edge.exported, edge);
+    }
+    index.set(fileName, names);
+  }
+  return index;
+};
+var push = (walk, fileName, name) => {
+  const key2 = { fileName, name };
+  walk.keys.push(key2);
+};
+var deeper = (walk) => {
+  const next = {
+    visited: walk.visited,
+    depth: walk.depth + 1,
+    keys: walk.keys
+  };
+  return next;
+};
+var isNewStep = (walk, key2) => {
+  if (walk.depth > MAX_DEPTH) return false;
+  const isVisited = walk.visited.has(key2);
+  if (isVisited) return false;
+  walk.visited.add(key2);
+  return true;
+};
+var markName = (context, fileName, name, walk) => {
+  const isNew = isNewStep(walk, `${fileName} ${name}`);
+  if (!isNew) return;
+  const edges = context.byFile.get(fileName);
+  if (!edges) return;
+  push(walk, fileName, name);
+  const reExport = context.reExportsByName.get(fileName)?.get(name);
+  if (reExport) {
+    markName(context, reExport.target, reExport.source, deeper(walk));
+  }
+  const isDeclaredLocally = edges.declared.has(name);
+  if (isDeclaredLocally) return;
+  for (const target of edges.starTargets) {
+    markName(context, target, name, deeper(walk));
+  }
+};
+var markAll = (context, fileName, walk) => {
+  const isNew = isNewStep(walk, `${fileName} ${STAR_NAME}`);
+  if (!isNew) return;
+  const edges = context.byFile.get(fileName);
+  if (!edges) return;
+  for (const name of edges.exports) {
+    push(walk, fileName, name);
+  }
+  for (const edge of edges.reExports) {
+    markName(context, edge.target, edge.source, deeper(walk));
+  }
+  for (const target of edges.starTargets) {
+    markAll(context, target, deeper(walk));
+  }
+};
+var markUsage = (context, target, name) => {
+  const keys = [];
+  const walk = { visited: /* @__PURE__ */ new Set(), depth: 0, keys };
+  if (name === STAR_NAME) {
+    markAll(context, target, walk);
+    return keys;
+  }
+  markName(context, target, name, walk);
+  return keys;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/aggregate-update.util.ts
+var countDelta = (counts, key2, delta) => {
+  const current = counts.get(key2);
+  const next = (current ?? 0) + delta;
+  if (next > 0) {
+    counts.set(key2, next);
+    return;
+  }
+  counts.delete(key2);
+};
+var usageDelta = (usage, key2, delta) => {
+  const existing = usage.get(key2.fileName);
+  const names = existing ?? /* @__PURE__ */ new Map();
+  const current = names.get(key2.name);
+  const next = (current ?? 0) + delta;
+  if (next > 0) names.set(key2.name, next);
+  else names.delete(key2.name);
+  if (names.size > 0) usage.set(key2.fileName, names);
+  else usage.delete(key2.fileName);
+};
+var fileContribution = (context, edges) => {
+  const usage = [];
+  const imported = [];
+  const starTouched = [];
+  for (const edge of edges.imports) {
+    imported.push(edge.target);
+    for (const name of edge.names) {
+      if (name === STAR_NAME) starTouched.push(edge.target);
+      const keys = markUsage(context, edge.target, name);
+      for (const key2 of keys) usage.push(key2);
+    }
+  }
+  for (const edge of edges.reExports) {
+    imported.push(edge.target);
+    starTouched.push(edge.target);
+  }
+  for (const target of edges.starTargets) {
+    imported.push(target);
+    starTouched.push(target);
+  }
+  const contribution = { usage, imported, starTouched };
+  return contribution;
+};
+var applyContribution = (aggregate, contribution, delta) => {
+  for (const key2 of contribution.usage) {
+    usageDelta(aggregate.usage, key2, delta);
+  }
+  for (const target of contribution.imported) {
+    countDelta(aggregate.imported, target, delta);
+  }
+  for (const target of contribution.starTouched) {
+    countDelta(aggregate.starTouched, target, delta);
+  }
+};
+var contextOf = (aggregate) => {
+  const context = {
+    byFile: aggregate.byFile,
+    reExportsByName: aggregate.reExportsByName
+  };
+  return context;
+};
+var addFile = (aggregate, edges) => {
+  const context = contextOf(aggregate);
+  const contribution = fileContribution(context, edges);
+  aggregate.contributions.set(edges.fileName, contribution);
+  applyContribution(aggregate, contribution, 1);
+};
+var buildAggregate = (byFile) => {
+  const aggregate = {
+    byFile,
+    usage: /* @__PURE__ */ new Map(),
+    imported: /* @__PURE__ */ new Map(),
+    reExportsByName: reExportIndex(byFile),
+    contributions: /* @__PURE__ */ new Map(),
+    starTouched: /* @__PURE__ */ new Map()
+  };
+  for (const edges of byFile.values()) {
+    addFile(aggregate, edges);
+  }
+  return aggregate;
+};
+var dropFile = (aggregate, fileName) => {
+  const contribution = aggregate.contributions.get(fileName);
+  if (!contribution) return;
+  applyContribution(aggregate, contribution, -1);
+  aggregate.contributions.delete(fileName);
+};
+var replaceEdges = (aggregate, change) => {
+  if (!change.after) {
+    aggregate.byFile.delete(change.fileName);
+    aggregate.reExportsByName.delete(change.fileName);
+    return;
+  }
+  aggregate.byFile.set(change.fileName, change.after);
+  aggregate.reExportsByName.set(change.fileName, /* @__PURE__ */ new Map());
+};
+var updateAggregate = (aggregate, changes) => {
+  for (const change of changes) {
+    dropFile(aggregate, change.fileName);
+    replaceEdges(aggregate, change);
+  }
+  for (const change of changes) {
+    if (change.after) addFile(aggregate, change.after);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/file-changes.util.ts
+var fileChanges = (before, after) => {
+  const changes = [];
+  for (const [fileName, edges] of after) {
+    const previous = before.get(fileName);
+    if (previous === edges) continue;
+    const change = { fileName, before: previous, after: edges };
+    changes.push(change);
+  }
+  for (const [fileName, edges] of before) {
+    const isKept = after.has(fileName);
+    if (isKept) continue;
+    const change = { fileName, before: edges, after: void 0 };
+    changes.push(change);
+  }
+  return changes;
+};
+var isBarrel = (edges) => {
+  if (!edges) return false;
+  const hasStarTargets = edges.starTargets.length > 0;
+  return edges.reExports.length > 0 || hasStarTargets;
+};
+var hasSameExports = (change) => {
+  const before = change.before?.exports ?? [];
+  const after = change.after?.exports ?? [];
+  if (before.length !== after.length) return false;
+  return before.every((name, index) => name === after[index]);
+};
+var isIncremental = (changes, starTouched) => {
+  for (const change of changes) {
+    const wasBarrel = isBarrel(change.before);
+    const isNowBarrel = isBarrel(change.after);
+    const touchesBarrel = wasBarrel || isNowBarrel;
+    if (touchesBarrel) return false;
+    const isStarTouched = starTouched.has(change.fileName);
+    if (!isStarTouched) continue;
+    const sameExports = hasSameExports(change);
+    if (!sameExports) return false;
+  }
+  return true;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-edges.util.ts
+import {
+  SyntaxKind as SyntaxKind7,
+  forEachChild as forEachChild5,
+  isCallExpression as isCallExpression4,
+  isExportAssignment,
+  isExportDeclaration,
+  isImportDeclaration as isImportDeclaration2,
+  isModuleDeclaration,
+  isNamespaceImport
+} from "typescript";
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/export-edges.util.ts
+import { isNamespaceExport } from "typescript";
+var addNamespaceExport = (clause, edges, target) => {
+  const exported = clause.name.text;
+  edges.exports.push(exported);
+  edges.declared.add(exported);
+  if (target === void 0) return;
+  const edge = { target, names: ["*"] };
+  edges.imports.push(edge);
+};
+var addExportFrom = (statement, edges, resolve5) => {
+  const target = resolve5(statement.moduleSpecifier);
+  const clause = statement.exportClause;
+  if (!clause) {
+    if (target !== void 0) edges.starTargets.push(target);
+    return;
+  }
+  if (isNamespaceExport(clause)) {
+    addNamespaceExport(clause, edges, target);
+    return;
+  }
+  for (const element of clause.elements) {
+    const origin = element.propertyName ?? element.name;
+    const exported = element.name.text;
+    edges.exports.push(exported);
+    if (target === void 0) continue;
+    const edge = { target, source: origin.text, exported };
+    edges.reExports.push(edge);
+  }
+};
+var addLocalExport = (statement, edges) => {
+  const clause = statement.exportClause;
+  if (!clause) return;
+  if (isNamespaceExport(clause)) return;
+  for (const element of clause.elements) {
+    const exported = element.name.text;
+    edges.exports.push(exported);
+    edges.declared.add(exported);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/exported-names.util.ts
+import {
+  SyntaxKind as SyntaxKind6,
+  canHaveModifiers,
+  getModifiers,
+  isClassDeclaration,
+  isEnumDeclaration,
+  isFunctionDeclaration as isFunctionDeclaration2,
+  isIdentifier as isIdentifier10,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration,
+  isVariableStatement
+} from "typescript";
+var hasModifier = (statement, kind) => {
+  if (!canHaveModifiers(statement)) return false;
+  const modifiers = getModifiers(statement);
+  const matched = modifiers?.some((modifier) => modifier.kind === kind);
+  return matched === true;
+};
+var variableNames = (statement) => {
+  const names = [];
+  for (const declaration of statement.declarationList.declarations) {
+    if (!isIdentifier10(declaration.name)) continue;
+    names.push(declaration.name.text);
+  }
+  return names;
+};
+var declaredName = (statement) => {
+  if (isFunctionDeclaration2(statement)) return statement.name?.text;
+  if (isClassDeclaration(statement)) return statement.name?.text;
+  if (isTypeAliasDeclaration(statement)) return statement.name.text;
+  if (isInterfaceDeclaration(statement)) return statement.name.text;
+  if (isEnumDeclaration(statement)) return statement.name.text;
+  return void 0;
+};
+var exportedNames = (statement) => {
+  const isExported = hasModifier(statement, SyntaxKind6.ExportKeyword);
+  if (!isExported) return [];
+  const isDefault = hasModifier(statement, SyntaxKind6.DefaultKeyword);
+  if (isDefault) return ["default"];
+  if (isVariableStatement(statement)) return variableNames(statement);
+  const name = declaredName(statement);
+  if (name === void 0) return [];
+  return [name];
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-target.util.ts
+var declarationOf = (specifier, checker) => {
+  const symbol = checker.getSymbolAtLocation(specifier);
+  if (!symbol) return void 0;
+  return symbol.valueDeclaration ?? symbol.declarations?.[0];
+};
+var moduleTarget = (specifier, checker, isExternal) => {
+  if (!specifier) return void 0;
+  const declaration = declarationOf(specifier, checker);
+  if (!declaration) return void 0;
+  const sourceFile = declaration.getSourceFile();
+  if (sourceFile.isDeclarationFile) return void 0;
+  const isSourceExternal = isExternal(sourceFile);
+  if (isSourceExternal) return void 0;
+  return sourceFile.fileName;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/module-edges.util.ts
+var importNames = (clause) => {
+  if (!clause) return [];
+  const names = [];
+  if (clause.name) names.push("default");
+  const bindings = clause.namedBindings;
+  if (!bindings) return names;
+  if (isNamespaceImport(bindings)) {
+    names.push("*");
+    return names;
+  }
+  for (const element of bindings.elements) {
+    const origin = element.propertyName ?? element.name;
+    names.push(origin.text);
+  }
+  return names;
+};
+var addImport2 = (statement, edges, resolve5) => {
+  const target = resolve5(statement.moduleSpecifier);
+  if (target === void 0) return;
+  const names = importNames(statement.importClause);
+  const edge = { target, names };
+  edges.imports.push(edge);
+};
+var DYNAMIC_IMPORT_TEXT = "import(";
+var dynamicImportTarget = (node, resolve5) => {
+  if (!isCallExpression4(node)) return void 0;
+  const isDynamicImport = node.expression.kind === SyntaxKind7.ImportKeyword;
+  if (!isDynamicImport) return void 0;
+  return resolve5(node.arguments[0]);
+};
+var collectDynamicImports = (node, resolve5, targets) => {
+  const target = dynamicImportTarget(node, resolve5);
+  if (target !== void 0) targets.push(target);
+  forEachChild5(node, (child) => {
+    collectDynamicImports(child, resolve5, targets);
+  });
+};
+var addDynamicImports = (sourceFile, edges, resolve5) => {
+  const hasDynamicImport = sourceFile.text.includes(DYNAMIC_IMPORT_TEXT);
+  if (!hasDynamicImport) return;
+  const targets = [];
+  collectDynamicImports(sourceFile, resolve5, targets);
+  for (const target of targets) {
+    const edge = { target, names: ["*"] };
+    edges.imports.push(edge);
+  }
+};
+var addDefaultExport = (edges) => {
+  edges.exports.push("default");
+  edges.declared.add("default");
+};
+var addDeclaredExports = (statement, edges) => {
+  for (const name of exportedNames(statement)) {
+    edges.exports.push(name);
+    edges.declared.add(name);
+  }
+};
+var emptyEdges = () => {
+  const edges = {
+    exports: [],
+    declared: /* @__PURE__ */ new Set(),
+    imports: [],
+    reExports: [],
+    starTargets: []
+  };
+  return edges;
+};
+var moduleEdges = (sourceFile, checker, isExternal) => {
+  const resolve5 = (specifier) => moduleTarget(specifier, checker, isExternal);
+  const edges = emptyEdges();
+  let skipped = false;
+  for (const statement of sourceFile.statements) {
+    if (isImportDeclaration2(statement)) {
+      addImport2(statement, edges, resolve5);
+    } else if (isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier) addExportFrom(statement, edges, resolve5);
+      else addLocalExport(statement, edges);
+    } else if (isExportAssignment(statement)) {
+      if (statement.isExportEquals) skipped = true;
+      else addDefaultExport(edges);
+    } else if (isModuleDeclaration(statement)) {
+      skipped = true;
+    } else {
+      addDeclaredExports(statement, edges);
+    }
+  }
+  addDynamicImports(sourceFile, edges, resolve5);
+  const fileEdges2 = {
+    fileName: sourceFile.fileName,
+    ...edges,
+    skipped
+  };
+  return fileEdges2;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/public-exports.util.ts
+var publicExports = (context, entryFiles) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entryFile of entryFiles) {
+    const keys = markUsage(context, entryFile, STAR_NAME);
+    for (const key2 of keys) {
+      const names = index.get(key2.fileName) ?? /* @__PURE__ */ new Set();
+      names.add(key2.name);
+      index.set(key2.fileName, names);
+    }
+  }
+  return index;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/export-index.ts
+var FILE_EDGES = /* @__PURE__ */ new WeakMap();
+var AGGREGATES = /* @__PURE__ */ new WeakMap();
+var PUBLIC = /* @__PURE__ */ new WeakMap();
+var LAST_AGGREGATE = /* @__PURE__ */ new Map();
+var projectKey = (program) => {
+  const configFilePath = program.getCompilerOptions()["configFilePath"];
+  if (typeof configFilePath === "string") return configFilePath;
+  const directories = program.getRootFileNames().map(dirname10);
+  const uniqueDirectorySet = new Set(directories);
+  const uniqueDirectories = [...uniqueDirectorySet];
+  const sortedDirectories = uniqueDirectories.sort();
+  return sortedDirectories.join("|");
+};
+var fileEdges = (sourceFile, checker, isExternal) => {
+  const cached = FILE_EDGES.get(sourceFile);
+  if (cached) return cached;
+  const edges = moduleEdges(sourceFile, checker, isExternal);
+  FILE_EDGES.set(sourceFile, edges);
+  return edges;
+};
+var programEdges = (program) => {
+  const checker = program.getTypeChecker();
+  const isExternal = (sourceFile) => program.isSourceFileFromExternalLibrary(sourceFile);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    const isSourceExternal = isExternal(sourceFile);
+    if (isSourceExternal) continue;
+    byFile.set(sourceFile.fileName, fileEdges(sourceFile, checker, isExternal));
+  }
+  return byFile;
+};
+var nextAggregate = (byFile, previous) => {
+  if (!previous) return buildAggregate(byFile);
+  const changes = fileChanges(previous.byFile, byFile);
+  const isPatchable = isIncremental(changes, previous.starTouched);
+  if (!isPatchable) return buildAggregate(byFile);
+  updateAggregate(previous, changes);
+  PUBLIC.delete(previous);
+  return previous;
+};
+var exportIndex = (program) => {
+  const cached = AGGREGATES.get(program);
+  if (cached) return cached;
+  const key2 = projectKey(program);
+  const byFile = programEdges(program);
+  const aggregate = nextAggregate(byFile, LAST_AGGREGATE.get(key2));
+  AGGREGATES.set(program, aggregate);
+  LAST_AGGREGATE.set(key2, aggregate);
+  return aggregate;
+};
+var publicExportIndex = (aggregate, isEntry) => {
+  const byMatcher = PUBLIC.get(aggregate) ?? /* @__PURE__ */ new WeakMap();
+  const cached = byMatcher.get(isEntry);
+  if (cached) return cached;
+  const keys = aggregate.byFile.keys();
+  const fileNames = [...keys];
+  const entryFiles = fileNames.filter(isEntry);
+  const context = {
+    byFile: aggregate.byFile,
+    reExportsByName: aggregate.reExportsByName
   };
-  return accessibilities.filter(isOtherAccessibility).map(suggestionFor);
+  const index = publicExports(context, entryFiles);
+  byMatcher.set(isEntry, index);
+  PUBLIC.set(aggregate, byMatcher);
+  return index;
 };
-var explicit_accessibility_default = createRule3({
-  name: "explicit-accessibility",
-  meta: meta3,
-  defaultOptions: defaultOptions3,
-  create(context, [{ defaultAccessibility = "public" }]) {
-    const { sourceCode } = context;
-    const check = (node) => {
-      const isPrivate = isPrivateMember(node);
-      if (node.accessibility || isPrivate) return;
-      const target = reportTarget(node);
-      const isConstructorMember = isConstructor(node);
-      const usesPublic = isConstructorMember && defaultAccessibility !== "none";
-      const fixAccessibility = usesPublic ? "public" : defaultAccessibility;
-      const autoFix = autoFixOf(node, fixAccessibility, sourceCode);
-      const name = memberName2(target, sourceCode);
-      const data = { name };
-      const suggest = suggestionsOf(node, fixAccessibility, sourceCode);
-      const report = {
-        node: target,
-        messageId: "missingAccessibility",
-        data,
-        ...autoFix,
-        suggest
-      };
-      context.report(report);
-    };
-    const listeners = {
-      AccessorProperty: check,
-      MethodDefinition: check,
-      PropertyDefinition: check,
-      TSAbstractAccessorProperty: check,
-      TSAbstractMethodDefinition: check,
-      TSAbstractPropertyDefinition: check,
-      TSParameterProperty: check
-    };
-    return listeners;
-  }
-});
 
-// packages/lint-suite/src/lib/rules/no-inline-object-types/no-inline-object-types.ts
-import { ESLintUtils as ESLintUtils4, TSESTree as TSESTree11 } from "@typescript-eslint/utils";
-var docs4 = {
-  description: "Require nested object types inside a type alias to be extracted to a named type alias"
+// packages/lint-suite/src/lib/rules/no-unused-exports/utils/export-nodes.util.ts
+import { TSESTree as TSESTree25 } from "@typescript-eslint/utils";
+var { AST_NODE_TYPES } = TSESTree25;
+var exportedName = (exported) => {
+  if (exported.type === AST_NODE_TYPES.Identifier) return exported.name;
+  return exported.value;
+};
+var addVariableNodes = (declaration, nodes) => {
+  for (const declarator of declaration.declarations) {
+    const { id } = declarator;
+    if (id.type !== AST_NODE_TYPES.Identifier) continue;
+    nodes.set(id.name, id);
+  }
+};
+var addNamedDeclarationNode = (declaration, nodes) => {
+  const { id } = declaration;
+  if (!id) return;
+  if (id.type !== AST_NODE_TYPES.Identifier) return;
+  nodes.set(id.name, id);
+};
+var addNamedExportNodes = (statement, nodes) => {
+  for (const specifier of statement.specifiers) {
+    const name = exportedName(specifier.exported);
+    nodes.set(name, specifier);
+  }
+  const { declaration } = statement;
+  if (!declaration) return;
+  if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {
+    addVariableNodes(declaration, nodes);
+    return;
+  }
+  addNamedDeclarationNode(declaration, nodes);
 };
-var messages4 = {
-  inlineObjectType: "Inline object type must be extracted to a named type alias."
+var exportNodes = (program) => {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
+      nodes.set("default", statement);
+      continue;
+    }
+    if (statement.type !== AST_NODE_TYPES.ExportNamedDeclaration) continue;
+    addNamedExportNodes(statement, nodes);
+  }
+  return nodes;
 };
-var meta4 = {
-  type: "suggestion",
-  docs: docs4,
-  schema: [],
-  messages: messages4
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/report-unused-exports.ts
+var reportModule = (context, node) => {
+  const report3 = {
+    node,
+    messageId: "unusedModule"
+  };
+  context.report(report3);
+};
+var reportNames = ({
+  context,
+  edges,
+  node,
+  publicNames,
+  used
+}) => {
+  const nodes = exportNodes(node);
+  const uniqueExports = new Set(edges.exports);
+  for (const name of uniqueExports) {
+    const count = used?.get(name) ?? 0;
+    const isPublic = publicNames?.has(name) ?? false;
+    if (count > 0 || isPublic) continue;
+    const data = { name };
+    const target = nodes.get(name) ?? node;
+    const report3 = {
+      node: target,
+      messageId: "unusedExport",
+      data
+    };
+    context.report(report3);
+  }
 };
-var createRule4 = ESLintUtils4.RuleCreator(
-  () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
+var reportUnusedExports = ({
+  context,
+  isEntry,
+  node,
+  services
+}) => {
+  const sourceFile = services.esTreeNodeToTSNodeMap.get(node);
+  const aggregate = exportIndex(services.program);
+  const edges = aggregate.byFile.get(sourceFile.fileName);
+  if (!edges) return;
+  if (edges.skipped) return;
+  const hasStarExports = edges.starTargets.length > 0;
+  const hasExports = edges.exports.length > 0 || hasStarExports;
+  if (!hasExports) return;
+  const isImported = aggregate.imported.has(edges.fileName);
+  if (!isImported) {
+    reportModule(context, node);
+    return;
+  }
+  const used = aggregate.usage.get(edges.fileName);
+  const publicIndex = publicExportIndex(aggregate, isEntry);
+  const publicNames = publicIndex.get(edges.fileName);
+  const nameOptions = {
+    context,
+    edges,
+    node,
+    publicNames,
+    used
+  };
+  reportNames(nameOptions);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-exports/no-unused-exports.ts
+var createRule14 = ESLintUtils14.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-unused-exports"
 );
-var enclosingTypeAlias = (node) => {
-  let current = node.parent;
-  while (current && current.type !== TSESTree11.AST_NODE_TYPES.Program) {
-    if (current.type === TSESTree11.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      return current;
-    }
-    current = current.parent;
+var typedParserServices = (context) => {
+  try {
+    const services = ESLintUtils14.getParserServices(context, true);
+    if (!services.program) return void 0;
+    return services;
+  } catch {
+    return void 0;
   }
-  return void 0;
 };
-var no_inline_object_types_default = createRule4({
-  name: "no-inline-object-types",
-  meta: meta4,
-  defaultOptions: [],
-  create(context) {
+var ENTRY_POINT_MATCHERS = /* @__PURE__ */ new WeakMap();
+var entryPointMatcher = (entryPoints) => {
+  const cached = ENTRY_POINT_MATCHERS.get(entryPoints);
+  if (cached) return cached;
+  const matcher = compileGlobs(entryPoints);
+  ENTRY_POINT_MATCHERS.set(entryPoints, matcher);
+  return matcher;
+};
+var no_unused_exports_default = createRule14({
+  name: "no-unused-exports",
+  meta: meta14,
+  defaultOptions: defaultOptions7,
+  create(context, [{ entryPoints }]) {
+    const noListeners = {};
+    const isEntry = entryPointMatcher(entryPoints);
+    const isEntryFile = isEntry(context.filename);
+    if (isEntryFile) return noListeners;
+    const services = typedParserServices(context);
+    if (!services) return noListeners;
     const listeners = {
-      TSTypeLiteral(node) {
-        const isAliasBody = node.parent.type === TSESTree11.AST_NODE_TYPES.TSTypeAliasDeclaration;
-        if (isAliasBody) return;
-        const enclosingAlias = enclosingTypeAlias(node);
-        if (!enclosingAlias) return;
-        const report = {
-          node,
-          messageId: "inlineObjectType"
-        };
-        context.report(report);
+      Program(node) {
+        reportUnusedExports({ context, isEntry, node, services });
       }
     };
     return listeners;
@@ -4310,40 +6430,45 @@ var no_inline_object_types_default = createRule4({
 });
 
 // packages/lint-suite/src/lib/rules/one-line-guard/one-line-guard.ts
-import { ESLintUtils as ESLintUtils5, TSESTree as TSESTree12 } from "@typescript-eslint/utils";
-var docs5 = {
+import { ESLintUtils as ESLintUtils15, TSESTree as TSESTree26 } from "@typescript-eslint/utils";
+var docs15 = {
   description: "Require a lone return/throw/continue/break guard to drop its braces when the whole if statement fits on one line"
 };
-var messages5 = {
+var messages15 = {
   oneLineGuard: "Lone {{ keyword }} guard fits within {{ max }} columns; write it on one line without braces."
 };
-var schema4 = [
+var maxLineLengthSchema = {
+  type: "integer",
+  minimum: 1
+};
+var properties8 = {
+  maxLineLength: maxLineLengthSchema
+};
+var schema9 = [
   {
     type: "object",
-    properties: {
-      maxLineLength: { type: "integer", minimum: 1 }
-    },
+    properties: properties8,
     additionalProperties: false
   }
 ];
-var meta5 = {
+var meta15 = {
   type: "suggestion",
-  docs: docs5,
+  docs: docs15,
   fixable: "code",
-  schema: schema4,
-  messages: messages5
+  schema: schema9,
+  messages: messages15
 };
-var createRule5 = ESLintUtils5.RuleCreator(
+var createRule15 = ESLintUtils15.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#one-line-guard"
 );
 var GUARD_KEYWORDS = /* @__PURE__ */ new Set([
-  TSESTree12.AST_NODE_TYPES.ReturnStatement,
-  TSESTree12.AST_NODE_TYPES.ThrowStatement,
-  TSESTree12.AST_NODE_TYPES.ContinueStatement,
-  TSESTree12.AST_NODE_TYPES.BreakStatement
+  TSESTree26.AST_NODE_TYPES.ReturnStatement,
+  TSESTree26.AST_NODE_TYPES.ThrowStatement,
+  TSESTree26.AST_NODE_TYPES.ContinueStatement,
+  TSESTree26.AST_NODE_TYPES.BreakStatement
 ]);
 var soleStatement = (body) => {
-  if (body.type !== TSESTree12.AST_NODE_TYPES.BlockStatement) return void 0;
+  if (body.type !== TSESTree26.AST_NODE_TYPES.BlockStatement) return void 0;
   if (body.body.length !== 1) return void 0;
   return body.body[0];
 };
@@ -4356,17 +6481,21 @@ var guardStatement = (node) => {
   return statement;
 };
 var headText = (node, sourceCode) => {
-  return sourceCode.text.slice(node.range[0], node.consequent.range[0]).trimEnd();
+  const start = node.range[0];
+  const end = node.consequent.range[0];
+  const rawHead = sourceCode.text.slice(start, end);
+  return rawHead.trimEnd();
 };
 var collapsedLine = (node, head, bodyText, sourceCode) => {
   const line = sourceCode.lines[node.loc.start.line - 1] ?? "";
   const prefix = line.slice(0, node.loc.start.column);
   return `${prefix}${head} ${bodyText}`;
 };
-var one_line_guard_default = createRule5({
+var defaultOptions8 = [{ maxLineLength: 80 }];
+var one_line_guard_default = createRule15({
   name: "one-line-guard",
-  meta: meta5,
-  defaultOptions: [{ maxLineLength: 80 }],
+  meta: meta15,
+  defaultOptions: defaultOptions8,
   create(context, [{ maxLineLength }]) {
     const { sourceCode } = context;
     const listeners = {
@@ -4388,13 +6517,13 @@ var one_line_guard_default = createRule5({
         const keyword = keywordToken.value;
         const data = { keyword, max: maxLineLength };
         const fix = (fixer) => fixer.replaceText(node.consequent, bodyText);
-        const report = {
+        const report3 = {
           node,
           messageId: "oneLineGuard",
           data,
           fix
         };
-        context.report(report);
+        context.report(report3);
       }
     };
     return listeners;
@@ -4402,45 +6531,46 @@ var one_line_guard_default = createRule5({
 });
 
 // packages/lint-suite/src/lib/rules/readonly-type-properties/readonly-type-properties.ts
-import { ESLintUtils as ESLintUtils6, TSESTree as TSESTree13 } from "@typescript-eslint/utils";
-var docs6 = {
-  description: "Require readonly on primitive-typed type and interface properties"
+import { ESLintUtils as ESLintUtils16, TSESTree as TSESTree27 } from "@typescript-eslint/utils";
+var docs16 = {
+  description: "Require readonly on primitive-typed type and interface properties, and require array types to be written as T[] instead of readonly T[] or ReadonlyArray<T>"
 };
-var messages6 = {
-  missingReadonly: "Type property '{{ name }}' should be readonly. Disable this rule on the line if mutation is required."
+var messages16 = {
+  missingReadonly: "Type property '{{ name }}' should be readonly. Disable this rule on the line if mutation is required.",
+  readonlyArray: "Write a readonly array type as T[]."
 };
-var meta6 = {
+var meta16 = {
   type: "suggestion",
-  docs: docs6,
+  docs: docs16,
   fixable: "code",
   schema: [],
-  messages: messages6
+  messages: messages16
 };
-var createRule6 = ESLintUtils6.RuleCreator(
+var createRule16 = ESLintUtils16.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#readonly-type-properties"
 );
 var propertyName3 = (node, sourceCode) => {
-  if (node.key.type === TSESTree13.AST_NODE_TYPES.Identifier) {
+  if (node.key.type === TSESTree27.AST_NODE_TYPES.Identifier) {
     return node.key.name;
   }
   return sourceCode.getText(node.key);
 };
 var PRIMITIVE_KEYWORDS = /* @__PURE__ */ new Set([
-  TSESTree13.AST_NODE_TYPES.TSStringKeyword,
-  TSESTree13.AST_NODE_TYPES.TSNumberKeyword,
-  TSESTree13.AST_NODE_TYPES.TSBooleanKeyword,
-  TSESTree13.AST_NODE_TYPES.TSBigIntKeyword,
-  TSESTree13.AST_NODE_TYPES.TSSymbolKeyword,
-  TSESTree13.AST_NODE_TYPES.TSNullKeyword,
-  TSESTree13.AST_NODE_TYPES.TSUndefinedKeyword
+  TSESTree27.AST_NODE_TYPES.TSStringKeyword,
+  TSESTree27.AST_NODE_TYPES.TSNumberKeyword,
+  TSESTree27.AST_NODE_TYPES.TSBooleanKeyword,
+  TSESTree27.AST_NODE_TYPES.TSBigIntKeyword,
+  TSESTree27.AST_NODE_TYPES.TSSymbolKeyword,
+  TSESTree27.AST_NODE_TYPES.TSNullKeyword,
+  TSESTree27.AST_NODE_TYPES.TSUndefinedKeyword
 ]);
 var isPrimitive = (type) => {
   const isPrimitiveKeyword = PRIMITIVE_KEYWORDS.has(type.type);
   if (isPrimitiveKeyword) return true;
-  if (type.type === TSESTree13.AST_NODE_TYPES.TSLiteralType || type.type === TSESTree13.AST_NODE_TYPES.TSTemplateLiteralType) {
+  if (type.type === TSESTree27.AST_NODE_TYPES.TSLiteralType || type.type === TSESTree27.AST_NODE_TYPES.TSTemplateLiteralType) {
     return true;
   }
-  if (type.type === TSESTree13.AST_NODE_TYPES.TSUnionType || type.type === TSESTree13.AST_NODE_TYPES.TSIntersectionType) {
+  if (type.type === TSESTree27.AST_NODE_TYPES.TSUnionType || type.type === TSESTree27.AST_NODE_TYPES.TSIntersectionType) {
     return type.types.every(isPrimitive);
   }
   return false;
@@ -4452,9 +6582,29 @@ var readonlyFix = (node, sourceCode) => {
     return fixer.insertTextBefore(firstToken, "readonly ");
   };
 };
-var readonly_type_properties_default = createRule6({
+var NEEDS_PARENS = /* @__PURE__ */ new Set([
+  TSESTree27.AST_NODE_TYPES.TSUnionType,
+  TSESTree27.AST_NODE_TYPES.TSIntersectionType,
+  TSESTree27.AST_NODE_TYPES.TSFunctionType,
+  TSESTree27.AST_NODE_TYPES.TSConditionalType
+]);
+var arrayTypeText = (argument, sourceCode) => {
+  const argumentText = sourceCode.getText(argument);
+  const needsParens = NEEDS_PARENS.has(argument.type);
+  if (needsParens) return `(${argumentText})[]`;
+  return `${argumentText}[]`;
+};
+var readonlyArrayReport = (node, fix) => {
+  const report3 = {
+    node,
+    messageId: "readonlyArray",
+    fix
+  };
+  return report3;
+};
+var readonly_type_properties_default = createRule16({
   name: "readonly-type-properties",
-  meta: meta6,
+  meta: meta16,
   defaultOptions: [],
   create(context) {
     const { sourceCode } = context;
@@ -4466,13 +6616,629 @@ var readonly_type_properties_default = createRule6({
         const name = propertyName3(node, sourceCode);
         const data = { name };
         const fix = readonlyFix(node, sourceCode);
-        const report = {
+        const report3 = {
           node: node.key,
           messageId: "missingReadonly",
           data,
           fix
         };
-        context.report(report);
+        context.report(report3);
+      },
+      TSTypeOperator(node) {
+        if (node.operator !== "readonly" || !node.typeAnnotation) return;
+        const isArray = node.typeAnnotation.type === TSESTree27.AST_NODE_TYPES.TSArrayType;
+        if (!isArray) return;
+        const replacement = sourceCode.getText(node.typeAnnotation);
+        const fix = (fixer) => fixer.replaceText(node, replacement);
+        context.report(readonlyArrayReport(node, fix));
+      },
+      TSTypeReference(node) {
+        if (node.typeName.type !== TSESTree27.AST_NODE_TYPES.Identifier) return;
+        if (node.typeName.name !== "ReadonlyArray") return;
+        const params = node.typeArguments?.params ?? [];
+        if (params.length !== 1) return;
+        const [argument] = params;
+        if (!argument) return;
+        const replacement = arrayTypeText(argument, sourceCode);
+        const fix = (fixer) => fixer.replaceText(node, replacement);
+        context.report(readonlyArrayReport(node, fix));
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/ternary-branch-shape/ternary-branch-shape.ts
+import { ESLintUtils as ESLintUtils17, TSESTree as TSESTree28 } from "@typescript-eslint/utils";
+var docs17 = {
+  description: "Require ternary branches to hold only names, literals, or plain member access"
+};
+var messages17 = {
+  ternaryBranch: "Ternary {{ branch }} must be a name, literal, or plain member access; name the expression first."
+};
+var meta17 = {
+  type: "suggestion",
+  docs: docs17,
+  schema: [],
+  messages: messages17
+};
+var createRule17 = ESLintUtils17.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#ternary-branch-shape"
+);
+var isPlainMemberAccess = (node) => {
+  let current = node;
+  while (current.type === TSESTree28.AST_NODE_TYPES.MemberExpression) {
+    current = current.object;
+  }
+  return current.type !== TSESTree28.AST_NODE_TYPES.CallExpression;
+};
+var isAllowedBranch = (node) => {
+  if (node.type === TSESTree28.AST_NODE_TYPES.Identifier) return true;
+  if (node.type === TSESTree28.AST_NODE_TYPES.Literal) return true;
+  if (node.type === TSESTree28.AST_NODE_TYPES.TemplateLiteral) return true;
+  if (node.type === TSESTree28.AST_NODE_TYPES.UnaryExpression) {
+    return node.argument.type === TSESTree28.AST_NODE_TYPES.Literal;
+  }
+  if (node.type === TSESTree28.AST_NODE_TYPES.MemberExpression) {
+    return isPlainMemberAccess(node);
+  }
+  return false;
+};
+var ternary_branch_shape_default = createRule17({
+  name: "ternary-branch-shape",
+  meta: meta17,
+  defaultOptions: [],
+  create(context) {
+    const check = (node, branch) => {
+      const isAllowed = isAllowedBranch(node);
+      if (isAllowed) return;
+      const data = { branch };
+      const report3 = {
+        node,
+        messageId: "ternaryBranch",
+        data
+      };
+      context.report(report3);
+    };
+    const listeners = {
+      ConditionalExpression(node) {
+        check(node.consequent, "consequent");
+        check(node.alternate, "alternate");
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/test-file-shape/test-file-shape.ts
+import { ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/test-file-shape/common/test-file-shape.const.ts
+var docs18 = {
+  description: "Restrict test-support file shapes and enforce naming and typing on stub and mock exports"
+};
+var messages18 = {
+  forbiddenTestFile: "Test-support file shape '{{ shape }}' is not allowed; test-only files live under test/stubs, test/mocks, test/fixtures, or test/utils.",
+  stubName: "Stub export '{{ name }}' must be named in SCREAMING_SNAKE_CASE ending in '_STUB'.",
+  stubType: "Stub export '{{ name }}' is missing an explicit type annotation.",
+  mockName: "Mock export '{{ name }}' must be a camelCase name ending in 'Mock'.",
+  mockFactory: "Mock export '{{ name }}' must be a function that returns fresh spies.",
+  mockReturnType: "Mock export '{{ name }}' is missing an explicit return type."
+};
+var meta18 = {
+  type: "problem",
+  docs: docs18,
+  schema: [],
+  messages: messages18
+};
+var defaultOptions9 = [];
+var FORBIDDEN_SHAPES = [
+  { pattern: /\.spec-support\.ts$/, shape: ".spec-support.ts" },
+  { pattern: /\.spec-helper\.ts$/, shape: ".spec-helper.ts" },
+  { pattern: /\.test-utils\.ts$/, shape: ".test-utils.ts" },
+  { pattern: /-fixture\.ts$/, shape: "-fixture.ts" },
+  { pattern: /\/__mocks__\//, shape: "__mocks__/" },
+  { pattern: /\/helpers\//, shape: "helpers/" },
+  { pattern: /\/common\/stubs\//, shape: "common/stubs/" }
+];
+var STUB_FILE_PATTERN = /\/test\/stubs\/.+\.stub\.ts$/;
+var MOCK_FILE_PATTERN = /\/test\/mocks\/.+\.mock\.ts$/;
+var SPEC_UTIL_FILE_PATTERN = /\/test\/utils\/.+\.spec\.util\.ts$/;
+var TESTING_LIB_SEGMENT = "/testing/";
+var TEST_FIXTURES_SEGMENT = "/test/fixtures/";
+var FIXTURES_SEGMENT = /\/fixtures\//;
+var STUB_NAME_PATTERN = /^[A-Z0-9]+(_[A-Z0-9]+)*_STUB$/;
+var MOCK_NAME_PATTERN = /^[a-z][A-Za-z0-9]*Mock$/;
+
+// packages/lint-suite/src/lib/rules/test-file-shape/mock-exports.ts
+import { TSESTree as TSESTree29 } from "@typescript-eslint/utils";
+var isMockFile = (filename) => {
+  const isUnderTestMocks = MOCK_FILE_PATTERN.test(filename);
+  if (isUnderTestMocks) return true;
+  const isUnderTestingLib2 = filename.includes(TESTING_LIB_SEGMENT);
+  return isUnderTestingLib2 && filename.endsWith(".mock.ts");
+};
+var isMockIdentifier = (id) => id.type === TSESTree29.AST_NODE_TYPES.Identifier;
+var isMockFunction = (init) => {
+  if (init === null) return false;
+  const { type } = init;
+  if (type === TSESTree29.AST_NODE_TYPES.ArrowFunctionExpression) return true;
+  return type === TSESTree29.AST_NODE_TYPES.FunctionExpression;
+};
+var isConstVariableDeclaration = (declaration) => {
+  if (declaration.type !== TSESTree29.AST_NODE_TYPES.VariableDeclaration) {
+    return false;
+  }
+  return declaration.kind === "const";
+};
+var declarationName = (context, declaration) => {
+  if (declaration.type === TSESTree29.AST_NODE_TYPES.VariableDeclaration) {
+    const [firstDeclarator] = declaration.declarations;
+    return context.sourceCode.getText(firstDeclarator.id);
+  }
+  if ("id" in declaration && declaration.id !== null) {
+    return context.sourceCode.getText(declaration.id);
+  }
+  return context.sourceCode.getText(declaration);
+};
+var reportMock = (context, node, messageId, name) => {
+  const data = { name };
+  const descriptor = {
+    node,
+    messageId,
+    data
+  };
+  context.report(descriptor);
+};
+var checkMockDeclarator = (context, node) => {
+  const fallbackName = context.sourceCode.getText(node.id);
+  const name = isMockIdentifier(node.id) ? node.id.name : fallbackName;
+  const hasValidPattern = MOCK_NAME_PATTERN.test(name);
+  const hasValidName = isMockIdentifier(node.id) && hasValidPattern;
+  if (!hasValidName) {
+    reportMock(context, node.id, "mockName", name);
+  }
+  if (!isMockFunction(node.init)) {
+    reportMock(context, node.id, "mockFactory", name);
+    return;
+  }
+  const hasReturnType = node.init.returnType !== void 0;
+  if (hasReturnType) return;
+  reportMock(context, node.id, "mockReturnType", name);
+};
+var mockExportListeners = (context) => {
+  const listeners = {
+    ExportNamedDeclaration(node) {
+      if (node.declaration === null) return;
+      const { declaration } = node;
+      const isConstVar = isConstVariableDeclaration(declaration);
+      if (!isConstVar) {
+        const name = declarationName(context, declaration);
+        reportMock(context, node, "mockFactory", name);
+        return;
+      }
+      for (const declarator of declaration.declarations) {
+        checkMockDeclarator(context, declarator);
+      }
+    }
+  };
+  return listeners;
+};
+
+// packages/lint-suite/src/lib/rules/test-file-shape/stub-exports.ts
+import { TSESTree as TSESTree30 } from "@typescript-eslint/utils";
+var isStubFile = (filename) => {
+  const isUnderTestStubs = STUB_FILE_PATTERN.test(filename);
+  if (isUnderTestStubs) return true;
+  const isUnderTestingLib2 = filename.includes(TESTING_LIB_SEGMENT);
+  return isUnderTestingLib2 && filename.endsWith(".stub.ts");
+};
+var isStubIdentifier = (id) => id.type === TSESTree30.AST_NODE_TYPES.Identifier;
+var checkStubDeclarator = (context, node) => {
+  const fallbackName = context.sourceCode.getText(node.id);
+  const name = isStubIdentifier(node.id) ? node.id.name : fallbackName;
+  const hasValidPattern = STUB_NAME_PATTERN.test(name);
+  const hasValidName = isStubIdentifier(node.id) && hasValidPattern;
+  if (!hasValidName) {
+    const nameData = { name };
+    const nameReport = {
+      node: node.id,
+      messageId: "stubName",
+      data: nameData
+    };
+    context.report(nameReport);
+  }
+  const hasTypeAnnotation = node.id.typeAnnotation !== void 0;
+  if (hasTypeAnnotation) return;
+  const typeData = { name };
+  const typeReport = {
+    node: node.id,
+    messageId: "stubType",
+    data: typeData
+  };
+  context.report(typeReport);
+};
+var stubExportListeners = (context) => {
+  const listeners = {
+    "ExportNamedDeclaration > VariableDeclaration > VariableDeclarator"(node) {
+      checkStubDeclarator(context, node);
+    }
+  };
+  return listeners;
+};
+
+// packages/lint-suite/src/lib/rules/test-file-shape/test-file-shape.ts
+var createRule18 = ESLintUtils18.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#test-file-shape"
+);
+var isUnderTestingLib = (filename) => filename.includes(TESTING_LIB_SEGMENT);
+var misplacedFixtures = (filename) => {
+  const hasFixturesSegment = FIXTURES_SEGMENT.test(filename);
+  if (!hasFixturesSegment) return void 0;
+  const isTestFixtures = filename.includes(TEST_FIXTURES_SEGMENT);
+  if (isTestFixtures) return void 0;
+  return "fixtures/ outside test/fixtures/";
+};
+var misplacedShape = (filename) => {
+  const isTestingLib = isUnderTestingLib(filename);
+  if (isTestingLib) return void 0;
+  const isStub = filename.endsWith(".stub.ts");
+  const isPlacedStub = STUB_FILE_PATTERN.test(filename);
+  if (isStub && !isPlacedStub) return ".stub.ts outside test/stubs/";
+  const isMock = filename.endsWith(".mock.ts");
+  const isPlacedMock = MOCK_FILE_PATTERN.test(filename);
+  if (isMock && !isPlacedMock) return ".mock.ts outside test/mocks/";
+  const isSpecUtil = filename.endsWith(".spec.util.ts");
+  const isPlacedSpecUtil = SPEC_UTIL_FILE_PATTERN.test(filename);
+  if (isSpecUtil && !isPlacedSpecUtil) {
+    return ".spec.util.ts outside test/utils/";
+  }
+  return misplacedFixtures(filename);
+};
+var forbiddenShape = (filename) => {
+  const match = FORBIDDEN_SHAPES.find((entry) => entry.pattern.test(filename));
+  if (match) return match.shape;
+  return misplacedShape(filename);
+};
+var forbiddenTestFileListeners = (context, shape) => {
+  const listeners = {
+    Program(node) {
+      const data = { shape };
+      const report3 = {
+        node,
+        messageId: "forbiddenTestFile",
+        data
+      };
+      context.report(report3);
+    }
+  };
+  return listeners;
+};
+var test_file_shape_default = createRule18({
+  name: "test-file-shape",
+  meta: meta18,
+  defaultOptions: defaultOptions9,
+  create(context) {
+    const filename = context.filename.replaceAll("\\", "/");
+    const shape = forbiddenShape(filename);
+    if (shape) return forbiddenTestFileListeners(context, shape);
+    const isStub = isStubFile(filename);
+    if (isStub) return stubExportListeners(context);
+    const isMock = isMockFile(filename);
+    if (isMock) return mockExportListeners(context);
+    const noListeners = {};
+    return noListeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/type-placement/type-placement.ts
+import { ESLintUtils as ESLintUtils19, TSESTree as TSESTree31 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/type-placement/common/type-placement.const.ts
+var DEFAULT_INTERNAL_PATTERNS = [];
+var docs19 = {
+  description: "Require types to live in common/*.type.ts files, *.const.ts files to export only consts, and type-only imports to come from *.type.ts files or a common barrel"
+};
+var messages19 = {
+  typeOutsideTypeFile: "Exported type '{{ name }}' belongs in a common/*.type.ts or test/common/*.type.ts file, not here.",
+  valueInTypeFile: "A *.type.ts file may only export type aliases and interfaces.",
+  nonConstInConstFile: "A *.const.ts file may only export const variable declarations.",
+  typeImportNotFromTypeFile: "Type-only import from '{{ source }}' must come from a *.type.ts file or a common barrel."
+};
+var stringItems2 = { type: "string" };
+var internalPatternsSchema = {
+  type: "array",
+  items: stringItems2,
+  description: "Regular expressions matching internal, non-relative import sources that must point at a *.type.ts file. Empty by default: a workspace alias resolves to a library entry point, never to a type file."
+};
+var properties9 = {
+  internalPatterns: internalPatternsSchema
+};
+var optionsSchema8 = {
+  type: "object",
+  properties: properties9,
+  additionalProperties: false
+};
+var schema10 = [optionsSchema8];
+var meta19 = {
+  type: "problem",
+  docs: docs19,
+  schema: schema10,
+  messages: messages19
+};
+var defaultOptions10 = [
+  { internalPatterns: DEFAULT_INTERNAL_PATTERNS }
+];
+
+// packages/lint-suite/src/lib/rules/type-placement/type-placement.ts
+var TYPE_FILE_SUFFIX = ".type.ts";
+var CONST_FILE_SUFFIX = ".const.ts";
+var COMMON_SEGMENT = "/common/";
+var EXEMPT_FILE = /\.(spec|stub|d)\.ts$/;
+var STATE_TYPE_FILE = /(^|[./])state\.type\.ts$/;
+var FIXTURES_SEGMENT2 = "/fixtures/";
+var TYPE_FILE_SEGMENT = /\.type(\.ts)?$/;
+var COMMON_BARREL = /(^|\/)common(\/index(\.ts)?)?$/;
+var createRule19 = ESLintUtils19.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#type-placement"
+);
+var isExemptFile = (filename) => {
+  const isExemptSuffix = EXEMPT_FILE.test(filename);
+  if (isExemptSuffix) return true;
+  const isStateTypeFile = STATE_TYPE_FILE.test(filename);
+  if (isStateTypeFile) return true;
+  return filename.includes(FIXTURES_SEGMENT2);
+};
+var lastSegment = (source) => {
+  const segments = source.split("/");
+  return segments[segments.length - 1] ?? source;
+};
+var isTypeOnlySource = (source) => {
+  const isCommonBarrel = COMMON_BARREL.test(source);
+  if (isCommonBarrel) return true;
+  return TYPE_FILE_SEGMENT.test(lastSegment(source));
+};
+var isInternalSource = (source, patterns) => {
+  const isRelative = source.startsWith(".");
+  if (isRelative) return true;
+  return patterns.some((pattern) => pattern.test(source));
+};
+var isTypeDeclaration = (declaration) => {
+  const { type } = declaration;
+  if (type === TSESTree31.AST_NODE_TYPES.TSTypeAliasDeclaration) return true;
+  return type === TSESTree31.AST_NODE_TYPES.TSInterfaceDeclaration;
+};
+var isConstVariableDeclaration2 = (declaration) => {
+  if (declaration.type !== TSESTree31.AST_NODE_TYPES.VariableDeclaration) {
+    return false;
+  }
+  return declaration.kind === "const";
+};
+var report = (context, node, messageId, data) => {
+  const base2 = { node, messageId };
+  if (data === void 0) {
+    context.report(base2);
+    return;
+  }
+  const withData = {
+    node,
+    messageId,
+    data
+  };
+  context.report(withData);
+};
+var handleExport = (context, node, shape) => {
+  if (node.declaration === null) return;
+  const { declaration } = node;
+  if (isTypeDeclaration(declaration)) {
+    const isCommonTypeFile = shape.isTypeFile && shape.inCommon;
+    if (!isCommonTypeFile) {
+      const data = { name: declaration.id.name };
+      report(context, node, "typeOutsideTypeFile", data);
+    }
+  } else if (shape.isTypeFile) {
+    report(context, node, "valueInTypeFile", void 0);
+  }
+  const isConstVar = isConstVariableDeclaration2(declaration);
+  if (shape.isConstFile && !isConstVar) {
+    report(context, node, "nonConstInConstFile", void 0);
+  }
+};
+var handleTypeImport = (context, node, patterns) => {
+  const { value: source } = node.source;
+  const isInternal = isInternalSource(source, patterns);
+  if (!isInternal) return;
+  const isTypeSource = isTypeOnlySource(source);
+  if (isTypeSource) return;
+  report(context, node, "typeImportNotFromTypeFile", { source });
+};
+var type_placement_default = createRule19({
+  name: "type-placement",
+  meta: meta19,
+  defaultOptions: defaultOptions10,
+  create(context, [{ internalPatterns }]) {
+    const filename = context.filename.replaceAll("\\", "/");
+    const isExempt = isExemptFile(filename);
+    if (isExempt) {
+      const noListeners = {};
+      return noListeners;
+    }
+    const isTypeFile = filename.endsWith(TYPE_FILE_SUFFIX);
+    const isConstFile = filename.endsWith(CONST_FILE_SUFFIX);
+    const inCommon = filename.includes(COMMON_SEGMENT);
+    const shape = { isTypeFile, isConstFile, inCommon };
+    const internalPatternRegexes = internalPatterns.map(toRegExp);
+    const listeners = {
+      ExportNamedDeclaration(node) {
+        handleExport(context, node, shape);
+      },
+      'ImportDeclaration[importKind="type"]'(node) {
+        handleTypeImport(context, node, internalPatternRegexes);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/util-purity/util-purity.ts
+import { ESLintUtils as ESLintUtils20, TSESTree as TSESTree32 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/util-purity/common/util-purity.const.ts
+var DEFAULT_BANNED_MODULES = [
+  "node:fs",
+  "fs",
+  "node:fs/promises",
+  "fs/promises",
+  "node:child_process",
+  "child_process",
+  "node:os",
+  "os",
+  "node:process",
+  "process",
+  "node:http",
+  "http",
+  "node:https",
+  "https",
+  "node:net",
+  "net",
+  "node:worker_threads",
+  "worker_threads"
+];
+var docs20 = {
+  description: "Disallow impure, I/O-touching, or nondeterministic code inside *.util.ts files"
+};
+var messages20 = {
+  impureImport: "Importing '{{ source }}' makes this util impure; utils must not perform I/O.",
+  moduleLet: "Module-level `let` creates mutable shared state; utils must be pure.",
+  moduleState: "Module-level Map/Set/WeakMap/WeakSet is mutable shared state; utils must be pure.",
+  ambientAccess: "Accessing ambient '{{ name }}' makes this util impure and environment-dependent.",
+  nondeterministic: "'{{ name }}' is nondeterministic; a util must return the same output for the same input.",
+  impureCall: "Calling '{{ name }}' makes this util impure or side-effecting."
+};
+var stringItems3 = { type: "string" };
+var bannedModulesSchema = {
+  type: "array",
+  items: stringItems3,
+  description: "Import sources that are forbidden inside util files."
+};
+var properties10 = {
+  bannedModules: bannedModulesSchema
+};
+var optionsSchema9 = {
+  type: "object",
+  properties: properties10,
+  additionalProperties: false
+};
+var schema11 = [optionsSchema9];
+var meta20 = {
+  type: "problem",
+  docs: docs20,
+  schema: schema11,
+  messages: messages20
+};
+var defaultOptions11 = [
+  { bannedModules: DEFAULT_BANNED_MODULES }
+];
+var MODULE_LET_SELECTOR = 'Program > VariableDeclaration[kind="let"]';
+var MODULE_STATE_SELECTOR = "Program > VariableDeclaration > VariableDeclarator > NewExpression[callee.name=/^(Map|Set|WeakMap|WeakSet)$/]";
+var AMBIENT_SELECTOR = "MemberExpression[object.name=/^(process|globalThis|window|document|localStorage|sessionStorage|console)$/]";
+var NONDETERMINISTIC_SELECTORS = [
+  'MemberExpression[object.name="Date"][property.name="now"]',
+  'MemberExpression[object.name="Math"][property.name="random"]',
+  'MemberExpression[object.name="performance"][property.name="now"]',
+  'MemberExpression[object.name="crypto"][property.name="randomUUID"]'
+];
+var NONDETERMINISTIC_SELECTOR = NONDETERMINISTIC_SELECTORS.join(", ");
+var CALL_SELECTOR = "CallExpression[callee.name=/^(setTimeout|setInterval|fetch|inject|require)$/]";
+
+// packages/lint-suite/src/lib/rules/util-purity/util-purity.ts
+var UTIL_FILE = /\/utils\/[^/]+\.util\.ts$/;
+var TEST_SEGMENT = "/test/";
+var TESTING_SEGMENT = "/testing/";
+var createRule20 = ESLintUtils20.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#util-purity"
+);
+var isUtilFile = (filename) => {
+  const isUtilPath = UTIL_FILE.test(filename);
+  if (!isUtilPath) return false;
+  const isUnderTest = filename.includes(TEST_SEGMENT) || filename.includes(TESTING_SEGMENT);
+  return !isUnderTest;
+};
+var identifierName = (node) => {
+  if (node.type !== TSESTree32.AST_NODE_TYPES.Identifier) return void 0;
+  return node.name;
+};
+var memberName3 = (node) => {
+  const objectName = identifierName(node.object);
+  if (objectName === void 0) return void 0;
+  const propertyName4 = identifierName(node.property);
+  if (propertyName4 === void 0) return void 0;
+  return `${objectName}.${propertyName4}`;
+};
+var report2 = (context, node, messageId, data) => {
+  const base2 = { node, messageId };
+  if (data === void 0) {
+    context.report(base2);
+    return;
+  }
+  const withData = {
+    node,
+    messageId,
+    data
+  };
+  context.report(withData);
+};
+var reportAmbient = (context, node) => {
+  const name = identifierName(node.object);
+  if (name === void 0) return;
+  report2(context, node, "ambientAccess", { name });
+};
+var reportNondeterministic = (context, node) => {
+  const name = memberName3(node);
+  if (name === void 0) return;
+  report2(context, node, "nondeterministic", { name });
+};
+var reportCall = (context, node) => {
+  const name = identifierName(node.callee);
+  if (name === void 0) return;
+  report2(context, node, "impureCall", { name });
+};
+var handleImport = (context, node, banned) => {
+  const { source } = node;
+  const isBanned = banned.has(source.value);
+  if (!isBanned) return;
+  report2(context, node, "impureImport", { source: source.value });
+};
+var util_purity_default = createRule20({
+  name: "util-purity",
+  meta: meta20,
+  defaultOptions: defaultOptions11,
+  create(context, [{ bannedModules }]) {
+    const filename = context.filename.replaceAll("\\", "/");
+    const isUtil = isUtilFile(filename);
+    if (!isUtil) {
+      const noListeners = {};
+      return noListeners;
+    }
+    const banned = new Set(bannedModules);
+    const listeners = {
+      ImportDeclaration(node) {
+        handleImport(context, node, banned);
+      },
+      [MODULE_LET_SELECTOR](node) {
+        report2(context, node, "moduleLet", void 0);
+      },
+      [MODULE_STATE_SELECTOR](node) {
+        report2(context, node, "moduleState", void 0);
+      },
+      [AMBIENT_SELECTOR](node) {
+        reportAmbient(context, node);
+      },
+      [NONDETERMINISTIC_SELECTOR](node) {
+        reportNondeterministic(context, node);
+      },
+      [CALL_SELECTOR](node) {
+        reportCall(context, node);
       }
     };
     return listeners;
@@ -4481,10 +7247,24 @@ var readonly_type_properties_default = createRule6({
 
 // packages/lint-suite/src/lib/typescript-local-plugin.ts
 var localPlugin = definePlugin("local", {
+  "arrow-body-fits-line": arrow_body_fits_line_default,
+  "chain-fits-line": chain_fits_line_default,
+  "chain-receiver-is-name": chain_receiver_is_name_default,
   "explicit-accessibility": explicit_accessibility_default,
-  "readonly-type-properties": readonly_type_properties_default,
+  "max-condition-operands": max_condition_operands_default,
+  "no-call-in-condition": no_call_in_condition_default,
+  "no-grouped-condition": no_grouped_condition_default,
   "no-inline-object-types": no_inline_object_types_default,
-  "one-line-guard": one_line_guard_default
+  "no-inline-return-object": no_inline_return_object_default,
+  "no-nested-object-value": no_nested_object_value_default,
+  "no-spread-expression": no_spread_expression_default,
+  "no-unused-exports": no_unused_exports_default,
+  "one-line-guard": one_line_guard_default,
+  "readonly-type-properties": readonly_type_properties_default,
+  "ternary-branch-shape": ternary_branch_shape_default,
+  "test-file-shape": test_file_shape_default,
+  "type-placement": type_placement_default,
+  "util-purity": util_purity_default
 });
 
 // packages/lint-suite/src/lib/typescript-safety.ts
@@ -4493,11 +7273,82 @@ var typescriptSafety = defineConfig18([
     files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
     plugins: { local: localPlugin },
     rules: {
+      // Expression arrow whose body wraps gets a block body. Fixes.
+      // Bad: (x) => a &&  b on two lines   Good: (x) => { return a && b; }
+      "local/arrow-body-fits-line": "error",
+      // Two or more calls in one chain stay on one line.
+      // Bad: a .b() .c() over three lines   Good: const b = a.b(); b.c();
+      "local/chain-fits-line": "error",
+      // A member chain starts on a name, never on an inline expression.
+      // Bad: (a ?? b).c   Good: const ab = a ?? b; ab.c
+      "local/chain-receiver-is-name": "error",
+      // Every class member states public, private, or protected. Fixes.
+      // Bad: field = 1;   Good: private field = 1;
       "local/explicit-accessibility": "error",
-      "local/readonly-type-properties": "error",
+      // An if condition holds at most 3 operands joined by && or ||.
+      // Bad: if (a && b && c && d)   Good: const isAll = a && b && c && d;
+      "local/max-condition-operands": "error",
+      // No call inside an if; type predicates and this.x() reads are exempt.
+      // Bad: if (validate(o))   Good: const isValid = validate(o); if (isValid)
+      "local/no-call-in-condition": "error",
+      // No parenthesised group with a different operator inside an if.
+      // Bad: if (a && (b || c))   Good: const isBOrC = b || c; if (a && isBOrC)
+      "local/no-grouped-condition": "error",
+      // An object type literal appears only as the body of a type alias.
+      // Bad: (f: { a: string })   Good: type F = { a: string }; (f: F)
       "local/no-inline-object-types": "error",
+      // Never return an object literal inline; name it first.
+      // Bad: return { a: 1 };   Good: const result = { a: 1 }; return result;
+      "local/no-inline-return-object": "error",
+      // A nested object, array of objects, ternary, or chain as a value gets a
+      // name.
+      // Bad: { a: { b: 1 } }   Good: const a = { b: 1 }; { a }
+      "local/no-nested-object-value": "error",
+      // Spread only a name or a member access.
+      // Bad: f(...getArgs())   Good: const args = getArgs(); f(...args)
+      "local/no-spread-expression": "error",
+      // An export no file in the program imports is dead; entry points exempt.
+      // Bad: export const unused = 1;   Good: delete it, or import it
+      "local/no-unused-exports": "error",
+      // A lone return/throw/continue/break guard drops braces when it fits.
+      // Bad: braced three-line if (x) { return; }   Good: if (x) return;
       "local/one-line-guard": ["error", { maxLineLength: MAX_LINE_LENGTH }],
+      // Type properties are readonly; arrays stay T[], never readonly T[].
+      // Fixes.
+      // Bad: { id: string; items: readonly T[] }
+      // Good: { readonly id: string; readonly items: T[] }
+      "local/readonly-type-properties": "error",
+      // A ternary branch is a name, literal, or plain member access.
+      // Bad: c ? foo() : b   Good: const called = foo(); c ? called : b
+      "local/ternary-branch-shape": "error",
+      // No spec-support, helpers, or __mocks__ files; stubs, mocks, and
+      // spec utils live under test/; stubs are UPPER_SNAKE_STUB: Type.
+      // Bad: user.spec-helper.ts, common/stubs/user.stub.ts
+      // Good: test/utils/user.spec.util.ts, test/stubs USER_STUB: User
+      "local/test-file-shape": "error",
+      // Exported types live in common/*.type.ts; type-only imports come from
+      // there.
+      // Bad: export type Order in order.ts
+      // Good: export type Order in common/order.type.ts
+      "local/type-placement": "error",
+      // utils/*.util.ts hold pure code: no fs, process, Date.now, module-level
+      // let or Map. Files under test/ or testing/ are exempt.
+      // Bad: const cache = new Map(); at module level
+      // Good: pass the state in as an argument
+      "local/util-purity": "error",
       "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/parameter-properties": "error",
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "TSEnumDeclaration[declare!=true]",
+          message: "enum is not erasable syntax; use a union of literals or an as-const object."
+        },
+        {
+          selector: 'TSModuleDeclaration[kind="namespace"][declare!=true]',
+          message: "namespace is not erasable syntax; use a module."
+        }
+      ],
       "@typescript-eslint/no-empty-function": "error",
       "@typescript-eslint/no-unused-vars": "error",
       "@typescript-eslint/no-use-before-define": "error",
@@ -4560,6 +7411,13 @@ var typescriptSafety = defineConfig18([
       "@typescript-eslint/prefer-string-starts-ends-with": "error",
       "@typescript-eslint/prefer-regexp-exec": "error"
     }
+  },
+  {
+    files: ["**/*.action.ts"],
+    rules: {
+      // Class actions carry their payload as constructor parameter properties.
+      "@typescript-eslint/parameter-properties": "off"
+    }
   }
 ]);
 
@@ -4576,7 +7434,8 @@ var typescript = defineConfig19([
 import vitestEslint from "@vitest/eslint-plugin";
 import { defineConfig as defineConfig20 } from "eslint/config";
 var vitestPlugin = {
-  vitest: vitestEslint
+  vitest: vitestEslint,
+  local: localPlugin
 };
 var vitest = defineConfig20([
   {