lint-suite 1.6.0 → 1.6.2

package/eslint.cjs

@@ -52,10 +52,7 @@ var import_config = require("eslint/config");
 var angularTemplate = (0, import_config.defineConfig)([
   {
     files: ["**/*.html"],
-    extends: [
-      ...import_angular_eslint.configs.templateAccessibility,
-      ...import_angular_eslint.configs.templateRecommended
-    ],
+    extends: [...import_angular_eslint.configs.templateAccessibility, ...import_angular_eslint.configs.templateRecommended],
     rules: {
       "@angular-eslint/template/prefer-template-literal": "error",
       "@angular-eslint/template/no-any": "error",
@@ -124,50 +121,343 @@ var angularTemplate = (0, import_config.defineConfig)([
 ]);
 
 // packages/lint-suite/src/lib/angular.ts
-var import_globals = __toESM(require("globals"), 1);
 var import_angular_eslint2 = require("angular-eslint");
 var import_config2 = require("eslint/config");
+var import_globals = __toESM(require("globals"), 1);
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
-var import_utils4 = require("@typescript-eslint/utils");
+// packages/lint-suite/src/lib/rules/define-plugin.util.ts
+var definePlugin = (name, rules) => {
+  const meta5 = { name };
+  const plugin = { meta: meta5, rules };
+  return plugin;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
+var import_utils10 = require("@typescript-eslint/utils");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-imports.ts
+var import_utils = require("@typescript-eslint/utils");
+var calleeRoot = (node) => {
+  if (node.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) return node;
+  if (node.type !== import_utils.TSESTree.AST_NODE_TYPES.MemberExpression || node.object.type === import_utils.TSESTree.AST_NODE_TYPES.Super) {
+    return void 0;
+  }
+  return calleeRoot(node.object);
+};
+var angularName = (node, imports) => {
+  if (node.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+    return imports.get(node.name);
+  }
+  if (node.type !== import_utils.TSESTree.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  if (node.object.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+    const namespaceAlias = imports.get(node.object.name);
+    if (namespaceAlias === null) return node.property.name;
+  }
+  return angularName(node.object, imports);
+};
+var isImportBinding = (node, sourceCode) => {
+  const root = calleeRoot(node);
+  if (!root) return false;
+  for (let scope = sourceCode.getScope(root); scope; scope = scope.upper) {
+    const variable = scope.set.get(root.name);
+    if (variable) return variable.defs[0]?.type === "ImportBinding";
+  }
+  return false;
+};
+var addAngularImport = (node, imports) => {
+  if (node.source.value !== "@angular/core" || node.importKind === "type") {
+    return;
+  }
+  for (const specifier of node.specifiers) {
+    if (specifier.type === import_utils.TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+      imports.set(specifier.local.name, null);
+    } else if (specifier.type === import_utils.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
+      const { imported } = specifier;
+      const isIdentifier8 = imported.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier;
+      const importedName = isIdentifier8 ? imported.name : imported.value;
+      imports.set(specifier.local.name, importedName);
+    }
+  }
+};
+var angularClassMetadata = (node, imports) => {
+  for (const decorator of node.decorators) {
+    if (decorator.expression.type !== import_utils.TSESTree.AST_NODE_TYPES.CallExpression) {
+      continue;
+    }
+    const kind = angularName(decorator.expression.callee, imports);
+    const metadata = decorator.expression.arguments.at(0);
+    const isComponentOrDirective = kind === "Component" || kind === "Directive";
+    if (isComponentOrDirective && metadata?.type === import_utils.TSESTree.AST_NODE_TYPES.ObjectExpression) {
+      const classMetadata = {
+        component: kind === "Component",
+        metadata
+      };
+      return classMetadata;
+    }
+  }
+  return null;
+};
+var angularClassImports = (ast) => {
+  const imports = /* @__PURE__ */ new Map();
+  for (const node of ast.body) {
+    if (node.type === import_utils.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+      addAngularImport(node, imports);
+    }
+  }
+  for (const imported of imports.values()) {
+    const isNamespaceImport = imported === null;
+    const isComponent = imported === "Component";
+    const isDirective = imported === "Directive";
+    const isAngularClassImport = isNamespaceImport || isComponent || isDirective;
+    if (isAngularClassImport) return imports;
+  }
+  return null;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-member-candidates.ts
+var import_utils3 = require("@typescript-eslint/utils");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-managed-fields.ts
 var import_utils2 = require("@typescript-eslint/utils");
+var managedApis = /* @__PURE__ */ new Set([
+  "input",
+  "model",
+  "output",
+  "viewChild",
+  "viewChildren",
+  "contentChild",
+  "contentChildren"
+]);
+var hasAutomaticEffectCleanup = (node) => {
+  const options = node.arguments.at(1);
+  if (options === void 0) return true;
+  if (options.type !== import_utils2.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
+  return options.properties.every((property) => {
+    if (property.type !== import_utils2.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+      return false;
+    }
+    const manualCleanup = property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup" || property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
+    return !manualCleanup || property.value.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.value.value === false;
+  });
+};
+var angularCoreImportedName = (definition) => {
+  if (definition?.type !== "ImportBinding") return null;
+  if (definition.node.type !== import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier) {
+    return null;
+  }
+  if (definition.parent.type !== import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+    return null;
+  }
+  if (definition.parent.source.value !== "@angular/core") return null;
+  const { imported } = definition.node;
+  if (imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+    return imported.name;
+  }
+  return imported.value;
+};
+var isAngularComponentRefField = (node, sourceCode) => {
+  const type = node.typeAnnotation?.typeAnnotation;
+  if (type?.type !== import_utils2.TSESTree.AST_NODE_TYPES.TSTypeReference || type.typeName.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+    return false;
+  }
+  const reference = sourceCode.getScope(type.typeName).references.find(({ identifier }) => identifier === type.typeName);
+  const definition = reference?.resolved?.defs[0];
+  return angularCoreImportedName(definition) === "ComponentRef";
+};
+var isManagedField = (node, imports, allowEffectFields, sourceCode) => {
+  if (node.value?.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) return false;
+  const name = angularName(node.value.callee, imports);
+  const isString = typeof name === "string";
+  if (!isString) return false;
+  const isManagedApi = managedApis.has(name);
+  if (isManagedApi) return true;
+  if (!allowEffectFields) return false;
+  if (name !== "effect") return false;
+  const isImported = isImportBinding(node.value.callee, sourceCode);
+  if (!isImported) return false;
+  return hasAutomaticEffectCleanup(node.value);
+};
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
-var import_node_fs = require("node:fs");
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-member-candidates.ts
+var lifecycleHooks = /* @__PURE__ */ new Set([
+  "ngOnChanges",
+  "ngOnInit",
+  "ngDoCheck",
+  "ngAfterContentInit",
+  "ngAfterContentChecked",
+  "ngAfterViewInit",
+  "ngAfterViewChecked",
+  "ngOnDestroy"
+]);
+var formsInterfaceMethods = {
+  AsyncValidator: ["validate", "registerOnValidatorChange"],
+  ControlValueAccessor: [
+    "writeValue",
+    "registerOnChange",
+    "registerOnTouched",
+    "setDisabledState"
+  ],
+  Validator: ["validate", "registerOnValidatorChange"]
+};
+var isInstanceField = (node) => {
+  if (node.type !== import_utils3.TSESTree.AST_NODE_TYPES.PropertyDefinition) return false;
+  return node.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier;
+};
+var isInstanceMethod = (node) => {
+  if (node.type !== import_utils3.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  return node.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier;
+};
+var isExcludedField = (node, localPrivateOnly, sourceCode) => {
+  const isModified = node.static || node.declare || node.override;
+  const isDecorated = node.decorators.length > 0;
+  if (isModified || isDecorated) return true;
+  const isComponentRef = isAngularComponentRefField(node, sourceCode);
+  if (isComponentRef) return true;
+  const isNonPrivate = node.accessibility !== "private";
+  return localPrivateOnly && isNonPrivate;
+};
+var isExcludedMethod = (node, localPrivateOnly, implementedMethods) => {
+  const isModified = node.static || node.override || node.computed;
+  const isDecorated = node.decorators.length > 0;
+  const isPlainMethod = node.kind === "method";
+  if (isModified || isDecorated || !isPlainMethod) return true;
+  const hasNoBody = node.value.body === null;
+  const isLifecycleHook = lifecycleHooks.has(node.key.name);
+  if (hasNoBody || isLifecycleHook) return true;
+  const isImplemented = implementedMethods.has(node.key.name);
+  if (isImplemented) return true;
+  const isNonPrivate = node.accessibility !== "private";
+  return localPrivateOnly && isNonPrivate;
+};
+var implementedFormsMethods = (node) => {
+  const methods = /* @__PURE__ */ new Set();
+  for (const heritage of node.implements) {
+    if (heritage.expression.type !== import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
+      continue;
+    }
+    for (const name of formsInterfaceMethods[heritage.expression.name] ?? []) {
+      methods.add(name);
+    }
+  }
+  return methods;
+};
+var fieldCandidate = (node, options) => {
+  const isField = isInstanceField(node);
+  if (!isField) return null;
+  const { localPrivateOnly, sourceCode } = options;
+  const isExcluded = isExcludedField(node, localPrivateOnly, sourceCode);
+  if (isExcluded) return null;
+  const isManaged = isManagedField(
+    node,
+    options.imports,
+    options.allowEffectFields,
+    sourceCode
+  );
+  if (isManaged) return null;
+  const unusedFieldCandidate = {
+    messageId: "unusedField",
+    name: node.key.name,
+    node
+  };
+  return unusedFieldCandidate;
+};
+var methodCandidate = (node, localPrivateOnly, implementedMethods) => {
+  const isMethod = isInstanceMethod(node);
+  if (!isMethod) return null;
+  const isExcluded = isExcludedMethod(
+    node,
+    localPrivateOnly,
+    implementedMethods
+  );
+  if (isExcluded) return null;
+  const unusedMethodCandidate = {
+    messageId: "unusedMethod",
+    name: node.key.name,
+    node
+  };
+  return unusedMethodCandidate;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
 var import_node_path = require("node:path");
+var import_utils5 = require("@typescript-eslint/utils");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-literals.ts
+var import_utils4 = require("@typescript-eslint/utils");
+var text = (node) => {
+  if (node?.type === import_utils4.TSESTree.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node?.type !== import_utils4.TSESTree.AST_NODE_TYPES.TemplateLiteral) return null;
+  const hasExpressions = node.expressions.length > 0;
+  if (hasExpressions) return null;
+  return node.quasis[0].value.cooked;
+};
+var key = (property) => {
+  if (property.type !== import_utils4.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+    return null;
+  }
+  if (property.key.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier) {
+    return property.key.name;
+  }
+  return text(property.key);
+};
+var metadataValue = (metadata, name) => {
+  for (const property of metadata.properties) {
+    if (property.type !== import_utils4.TSESTree.AST_NODE_TYPES.Property) continue;
+    const propertyKey = key(property);
+    if (propertyKey === name) return property.value;
+  }
+  return void 0;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-template-parsing.ts
+var import_compiler3 = require("@angular/compiler");
+var import_node_fs = require("node:fs");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
 var import_compiler2 = require("@angular/compiler");
-var import_utils = require("@typescript-eslint/utils");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/angular-expression-reads.util.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/angular-read-target.util.ts
 var import_compiler = require("@angular/compiler");
-var ReadCollector = class extends import_compiler.CombinedRecursiveAstVisitor {
+var isReadTarget = (node) => {
+  const isPropertyRead = node instanceof import_compiler.PropertyRead;
+  const isSafePropertyRead = node instanceof import_compiler.SafePropertyRead;
+  const isKeyedRead = node instanceof import_compiler.KeyedRead;
+  const isSafeKeyedRead = node instanceof import_compiler.SafeKeyedRead;
+  return isPropertyRead || isSafePropertyRead || isKeyedRead || isSafeKeyedRead;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
+var ReadCollector = class extends import_compiler2.CombinedRecursiveAstVisitor {
+  reads = /* @__PURE__ */ new Set();
+  boundTarget;
+  action;
   constructor(boundTarget, action) {
     super();
     this.boundTarget = boundTarget;
     this.action = action;
   }
-  boundTarget;
-  action;
-  reads = /* @__PURE__ */ new Set();
   record(node) {
-    if (node.receiver instanceof import_compiler.ThisReceiver) {
+    if (node.receiver instanceof import_compiler2.ThisReceiver) {
       this.reads.add(node.name);
       return;
     }
-    if (node.receiver instanceof import_compiler.ImplicitReceiver && (!this.action || node.name !== "$event") && !this.boundTarget?.getExpressionTarget(node)) {
-      this.reads.add(node.name);
-    }
+    if (!(node.receiver instanceof import_compiler2.ImplicitReceiver)) return;
+    const isBindableName = !this.action || node.name !== "$event";
+    if (!isBindableName) return;
+    const expressionTarget = this.boundTarget?.getExpressionTarget(node);
+    if (expressionTarget) return;
+    this.reads.add(node.name);
   }
   visitBinary(node, context) {
-    if (node.operation !== "=") {
-      return super.visitBinary(node, context);
-    }
-    if (node.left instanceof import_compiler.PropertyRead || node.left instanceof import_compiler.SafePropertyRead || node.left instanceof import_compiler.KeyedRead || node.left instanceof import_compiler.SafeKeyedRead) {
+    if (node.operation !== "=") return super.visitBinary(node, context);
+    if (isReadTarget(node.left)) {
       this.visit(node.left.receiver);
     }
-    if (node.left instanceof import_compiler.KeyedRead || node.left instanceof import_compiler.SafeKeyedRead) {
+    if (node.left instanceof import_compiler2.KeyedRead || node.left instanceof import_compiler2.SafeKeyedRead) {
       this.visit(node.left.key);
     }
     this.visit(node.right);
@@ -190,22 +480,14 @@ var collectAngularExpressionReads = (nodes, boundTarget, action) => {
   return collector.reads;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-template-parsing.ts
 var externalTemplates = /* @__PURE__ */ new Map();
-var parser = new import_compiler2.Parser(new import_compiler2.Lexer());
-var templateBinder = new import_compiler2.R3TargetBinder(null);
-var text = (node) => {
-  if (node?.type === import_utils.TSESTree.AST_NODE_TYPES.Literal && typeof node.value === "string") {
-    return node.value;
-  }
-  return node?.type === import_utils.TSESTree.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? node.quasis[0].value.cooked : null;
-};
+var parser = new import_compiler3.Parser(new import_compiler3.Lexer());
+var templateBinder = new import_compiler3.R3TargetBinder(null);
 var templateReads = (template, filename) => {
   try {
-    const result = (0, import_compiler2.parseTemplate)(template, filename);
-    if (result.errors?.length) {
-      return null;
-    }
+    const result = (0, import_compiler3.parseTemplate)(template, filename);
+    if (result.errors?.length) return null;
     return collectAngularExpressionReads(
       result.nodes,
       templateBinder.bind({ template: result.nodes }),
@@ -220,9 +502,7 @@ var externalTemplateReads = (filename) => {
     const stats = (0, import_node_fs.statSync)(filename, { bigint: true });
     const version = `${stats.mtimeNs}:${stats.size}`;
     const cached = externalTemplates.get(filename);
-    if (cached?.version === version) {
-      return cached.reads;
-    }
+    if (cached?.version === version) return cached.reads;
     const reads = templateReads((0, import_node_fs.readFileSync)(filename, "utf8"), filename);
     externalTemplates.set(filename, { reads, version });
     return reads;
@@ -230,82 +510,66 @@ var externalTemplateReads = (filename) => {
     return null;
   }
 };
+var parseExpression = (expression, span, action) => {
+  if (action) return parser.parseAction(expression, span, 0);
+  return parser.parseBinding(expression, span, 0);
+};
 var expressionReads = (expression, filename, action) => {
   try {
-    const file = new import_compiler2.ParseSourceFile(expression, filename);
-    const start = new import_compiler2.ParseLocation(file, 0, 0, 0);
-    const span = new import_compiler2.ParseSourceSpan(start, start.moveBy(expression.length));
-    const result = action ? parser.parseAction(expression, span, 0) : parser.parseBinding(expression, span, 0);
-    if (result.errors.length > 0) {
-      return null;
-    }
+    const file = new import_compiler3.ParseSourceFile(expression, filename);
+    const start = new import_compiler3.ParseLocation(file, 0, 0, 0);
+    const span = new import_compiler3.ParseSourceSpan(start, start.moveBy(expression.length));
+    const result = parseExpression(expression, span, action);
+    if (result.errors.length > 0) return null;
     return collectAngularExpressionReads([result], void 0, action);
   } catch {
     return null;
   }
 };
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
 var addReads = (target, source) => {
-  if (!source) {
-    return false;
-  }
+  if (!source) return false;
   for (const name of source) {
     target.add(name);
   }
   return true;
 };
-var key = (property) => {
-  if (property.type !== import_utils.TSESTree.AST_NODE_TYPES.Property || property.computed) {
-    return null;
-  }
-  return property.key.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier ? property.key.name : text(property.key);
-};
-var metadataValue = (metadata, name) => {
-  for (const property of metadata.properties) {
-    if (property.type === import_utils.TSESTree.AST_NODE_TYPES.Property && key(property) === name) {
-      return property.value;
-    }
-  }
-  return void 0;
-};
 var hostPropertyReads = (property, reads, filename) => {
   const name = key(property);
   const expression = text(property.value);
-  if (name === null || expression === null) {
-    return false;
-  }
-  if (name.startsWith("[")) {
+  if (name === null || expression === null) return false;
+  const isPropertyBinding = name.startsWith("[");
+  if (isPropertyBinding) {
     return addReads(reads, expressionReads(expression, filename, false));
   }
-  if (name.startsWith("(")) {
+  const isEventBinding = name.startsWith("(");
+  if (isEventBinding) {
     return addReads(reads, expressionReads(expression, filename, true));
   }
   return true;
 };
 var hostReads = (host, reads, filename) => {
-  if (!host) {
-    return true;
-  }
-  if (host.type !== import_utils.TSESTree.AST_NODE_TYPES.ObjectExpression || host.properties.some((property) => key(property) === null)) {
-    return false;
-  }
+  if (!host) return true;
+  if (host.type !== import_utils5.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
+  const hasUnreadableKey = host.properties.some(
+    (property) => key(property) === null
+  );
+  if (hasUnreadableKey) return false;
   for (const property of host.properties) {
-    if (property.type !== import_utils.TSESTree.AST_NODE_TYPES.Property || !hostPropertyReads(property, reads, filename)) {
-      return false;
-    }
+    if (property.type !== import_utils5.TSESTree.AST_NODE_TYPES.Property) return false;
+    const hasPropertyReads = hostPropertyReads(property, reads, filename);
+    if (!hasPropertyReads) return false;
   }
   return true;
 };
 var inlineTemplateReads = (template, reads, filename) => {
-  if (!template) {
-    return true;
-  }
+  if (!template) return true;
   const source = text(template);
   return source !== null && addReads(reads, templateReads(source, filename));
 };
 var externalTemplatePropertyReads = (templateUrl, reads, filename) => {
-  if (!templateUrl) {
-    return true;
-  }
+  if (!templateUrl) return true;
   const url = text(templateUrl);
   return url !== null && addReads(reads, externalTemplateReads((0, import_node_path.resolve)((0, import_node_path.dirname)(filename), url)));
 };
@@ -314,156 +578,113 @@ var componentTemplateReads = (metadata, reads, filename) => {
   const templateUrl = metadataValue(metadata, "templateUrl");
   return inlineTemplateReads(template, reads, filename) && externalTemplatePropertyReads(templateUrl, reads, filename);
 };
-var metadataReads = (metadata, component, filename, remainingNames) => {
-  if (metadata.properties.some((property) => key(property) === null)) {
-    return null;
-  }
+var metadataReads = (options) => {
+  const { filename, metadata } = options;
+  const isUnreadableKey = (property) => {
+    return key(property) === null;
+  };
+  const hasUnreadableKey = metadata.properties.some(isUnreadableKey);
+  if (hasUnreadableKey) return null;
   const reads = /* @__PURE__ */ new Set();
-  if (!hostReads(metadataValue(metadata, "host"), reads, filename)) {
-    return null;
-  }
-  if (component && remainingNames.every((name) => reads.has(name)) || !component || componentTemplateReads(metadata, reads, filename)) {
-    return reads;
-  }
+  const hostValue = metadataValue(metadata, "host");
+  const hasHostReads = hostReads(hostValue, reads, filename);
+  if (!hasHostReads) return null;
+  if (!options.component) return reads;
+  const isRead = (name) => reads.has(name);
+  const hasRemainingReads = options.remainingNames.every(isRead);
+  if (hasRemainingReads) return reads;
+  const hasTemplateReads = componentTemplateReads(metadata, reads, filename);
+  if (hasTemplateReads) return reads;
+  if (!options.requireTemplate) return reads;
   return null;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
-var managedApis = {
-  input: true,
-  model: true,
-  output: true
-};
-var angularName = (node, imports) => {
-  if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
-    return imports.get(node.name);
-  }
-  if (node.type !== import_utils2.TSESTree.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
-    return null;
-  }
-  if (node.object.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier && imports.get(node.object.name) === null) {
-    return node.property.name;
-  }
-  return angularName(node.object, imports);
-};
-var angularClass = (node, imports) => {
-  for (const decorator of node.decorators) {
-    if (decorator.expression.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) {
-      continue;
-    }
-    const kind = angularName(decorator.expression.callee, imports);
-    const metadata = decorator.expression.arguments[0];
-    if ((kind === "Component" || kind === "Directive") && metadata?.type === import_utils2.TSESTree.AST_NODE_TYPES.ObjectExpression) {
-      return {
-        component: kind === "Component",
-        metadata
-      };
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-class-fields.ts
+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);
+    if (candidate) {
+      members.push(candidate);
     }
   }
-  return null;
-};
-var isInstanceField = (node) => node.type === import_utils2.TSESTree.AST_NODE_TYPES.PropertyDefinition && node.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier;
-var lifecycleHooks = {
-  ngOnChanges: true,
-  ngOnInit: true,
-  ngDoCheck: true,
-  ngAfterContentInit: true,
-  ngAfterContentChecked: true,
-  ngAfterViewInit: true,
-  ngAfterViewChecked: true,
-  ngOnDestroy: true
-};
-var isInstanceMethod = (node) => node.type === import_utils2.TSESTree.AST_NODE_TYPES.MethodDefinition && node.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier;
-var isExcludedField = (node, component) => node.static || node.declare || node.override || node.decorators.length > 0 || !component && node.accessibility !== "private";
-var isManagedField = (node, imports) => {
-  if (node.value?.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) {
-    return false;
-  }
-  const name = angularName(node.value.callee, imports);
-  return typeof name === "string" && managedApis[name] === true;
+  return members;
 };
-var field = (node, imports, component) => {
-  if (isInstanceField(node) && !isExcludedField(node, component) && !isManagedField(node, imports)) {
-    return { messageId: "unusedField", name: node.key.name, node };
-  }
-  return null;
+var reportMember = (context, candidate) => {
+  const data = { name: candidate.name };
+  const report = {
+    data,
+    messageId: candidate.messageId,
+    node: candidate.node.key
+  };
+  context.report(report);
 };
-var isExcludedMethod = (node, component) => node.static || node.override || node.decorators.length > 0 || node.computed || node.kind !== "method" || node.value.body === null || lifecycleHooks[node.key.name] === true || !component && node.accessibility !== "private";
-var method = (node, component) => {
-  if (isInstanceMethod(node) && !isExcludedMethod(node, component)) {
-    return { messageId: "unusedMethod", name: node.key.name, node };
+var reportUnreadMembers = (members, reads, options) => {
+  for (const candidate of members) {
+    const isTemplateRead = reads.has(candidate.name);
+    if (isTemplateRead) continue;
+    const isProjectUsed = options.projectMemberUsed?.(candidate.node) === true;
+    if (isProjectUsed) continue;
+    reportMember(options.context, candidate);
   }
-  return null;
 };
-var addAngularImport = (node, imports) => {
-  if (node.source.value !== "@angular/core" || node.importKind === "type") {
-    return;
-  }
-  for (const specifier of node.specifiers) {
-    if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-      imports.set(specifier.local.name, null);
-    } else if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
-      const importedName = specifier.imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
-      imports.set(specifier.local.name, importedName);
-    }
-  }
+var reportClassMembers = (entry, ngClass, report) => {
+  const { options, projectAnalysis } = report;
+  const isLocalOnlyClass = !ngClass.component || entry.node.abstract === true;
+  const candidateOptions = {
+    allowEffectFields: options.allowEffectFields,
+    imports: options.imports,
+    localPrivateOnly: !projectAnalysis && isLocalOnlyClass,
+    sourceCode: options.context.sourceCode
+  };
+  const members = memberCandidates(entry.node, candidateOptions);
+  const unreadMembers = members.filter(
+    (candidate) => !entry.reads.has(candidate.name)
+  );
+  if (unreadMembers.length === 0) return;
+  const remainingNames = unreadMembers.map((candidate) => candidate.name);
+  const readsOptions = {
+    component: ngClass.component && report.localTemplates,
+    filename: options.context.filename,
+    metadata: ngClass.metadata,
+    remainingNames,
+    requireTemplate: !projectAnalysis
+  };
+  const reads = metadataReads(readsOptions);
+  if (!reads) return;
+  reportUnreadMembers(unreadMembers, reads, options);
 };
-var reportUnusedMembers = (context, imports, classes, dynamicClasses) => {
-  for (const entry of classes) {
-    const ngClass = angularClass(entry.node, imports);
-    if (!ngClass || dynamicClasses.has(entry)) {
-      continue;
-    }
-    const members = [];
-    for (const node of entry.node.body.body) {
-      const candidate = field(node, imports, ngClass.component) ?? method(node, ngClass.component);
-      if (candidate) {
-        members.push(candidate);
-      }
-    }
-    if (members.length === 0) {
-      continue;
-    }
-    const unreadMembers = members.filter(
-      (candidate) => !entry.reads.has(candidate.name)
-    );
-    if (unreadMembers.length === 0) {
-      continue;
-    }
-    const reads = metadataReads(
-      ngClass.metadata,
-      ngClass.component,
-      context.filename,
-      unreadMembers.map((candidate) => candidate.name)
-    );
-    if (!reads) {
-      continue;
-    }
-    for (const candidate of unreadMembers) {
-      if (!reads.has(candidate.name)) {
-        context.report({
-          data: { name: candidate.name },
-          messageId: candidate.messageId,
-          node: candidate.node.key
-        });
-      }
-    }
+var reportUnusedMembers = (options) => {
+  const projectAnalysis = options.projectMemberUsed !== void 0;
+  const localTemplates = !projectAnalysis || !options.projectIndexed();
+  const report = {
+    localTemplates,
+    options,
+    projectAnalysis
+  };
+  for (const entry of options.classes) {
+    const ngClass = angularClassMetadata(entry.node, options.imports);
+    const isDynamicClass = options.dynamicClasses.has(entry);
+    if (!ngClass || isDynamicClass) continue;
+    reportClassMembers(entry, ngClass, report);
   }
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/typescript-field-reads.util.ts
-var import_utils3 = require("@typescript-eslint/utils");
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-class-read-visitor.ts
+var import_utils9 = require("@typescript-eslint/utils");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-field-reads.ts
+var import_utils6 = require("@typescript-eslint/utils");
+var expressionWrapperTypes = /* @__PURE__ */ new Set([
+  import_utils6.TSESTree.AST_NODE_TYPES.TSAsExpression,
+  import_utils6.TSESTree.AST_NODE_TYPES.TSInstantiationExpression,
+  import_utils6.TSESTree.AST_NODE_TYPES.TSNonNullExpression,
+  import_utils6.TSESTree.AST_NODE_TYPES.TSSatisfiesExpression,
+  import_utils6.TSESTree.AST_NODE_TYPES.TSTypeAssertion
+]);
 var isTypeScriptExpressionWrapper = (node) => {
-  switch (node.type) {
-    case import_utils3.TSESTree.AST_NODE_TYPES.TSAsExpression:
-    case import_utils3.TSESTree.AST_NODE_TYPES.TSInstantiationExpression:
-    case import_utils3.TSESTree.AST_NODE_TYPES.TSNonNullExpression:
-    case import_utils3.TSESTree.AST_NODE_TYPES.TSSatisfiesExpression:
-    case import_utils3.TSESTree.AST_NODE_TYPES.TSTypeAssertion:
-      return true;
-    default:
-      return false;
-  }
+  return expressionWrapperTypes.has(node.type);
 };
 var unwrapTypeScriptExpression = (node) => {
   let current = node;
@@ -472,123 +693,215 @@ var unwrapTypeScriptExpression = (node) => {
   }
   return current;
 };
-var isThisExpression = (node) => unwrapTypeScriptExpression(node)?.type === import_utils3.TSESTree.AST_NODE_TYPES.ThisExpression;
-var isPatternTarget = (parent, child) => {
-  switch (parent?.type) {
-    case import_utils3.TSESTree.AST_NODE_TYPES.ArrayPattern:
-      return parent.elements.some((element) => element === child);
-    case import_utils3.TSESTree.AST_NODE_TYPES.AssignmentPattern:
-      return parent.left === child;
-    case import_utils3.TSESTree.AST_NODE_TYPES.ObjectPattern:
-      return parent.properties.some((property) => property === child);
-    case import_utils3.TSESTree.AST_NODE_TYPES.Property:
-      return parent.value === child && parent.parent.type === import_utils3.TSESTree.AST_NODE_TYPES.ObjectPattern;
-    case import_utils3.TSESTree.AST_NODE_TYPES.RestElement:
-      return parent.argument === child;
-    default:
-      return false;
-  }
-};
-var isSimpleAssignmentTarget = (parent, current) => parent?.type === import_utils3.TSESTree.AST_NODE_TYPES.AssignmentExpression && parent.left === current && parent.operator === "=";
-var isLoopTarget = (parent, current) => (parent?.type === import_utils3.TSESTree.AST_NODE_TYPES.ForInStatement || parent?.type === import_utils3.TSESTree.AST_NODE_TYPES.ForOfStatement) && parent.left === current;
-var isDirectWrite = (node) => {
-  let current = node;
-  let parent = node.parent;
-  while (parent && isTypeScriptExpressionWrapper(parent) && parent.expression === current) {
-    current = parent;
-    parent = parent.parent;
-  }
-  return isSimpleAssignmentTarget(parent, current) || parent?.type === import_utils3.TSESTree.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
-};
-var isDestructuringOrLoopTarget = (node) => {
-  let current = node;
-  let parent = node.parent;
-  let patternTarget = false;
-  while (parent) {
-    const wrapper = isTypeScriptExpressionWrapper(parent) && parent.expression === current;
-    const pattern = isPatternTarget(parent, current);
-    if (!wrapper && !pattern) {
-      break;
-    }
-    if (pattern) {
-      patternTarget = true;
-    }
-    current = parent;
-    parent = parent.parent;
-  }
-  return patternTarget && isSimpleAssignmentTarget(parent, current) || isLoopTarget(parent, current);
+var isThisExpression = (node) => {
+  const unwrapped = unwrapTypeScriptExpression(node);
+  return unwrapped?.type === import_utils6.TSESTree.AST_NODE_TYPES.ThisExpression;
 };
-var isWriteOnly = (node) => isDirectWrite(node) || isDestructuringOrLoopTarget(node);
 var destructuringParts = (node) => {
-  if (node.type === import_utils3.TSESTree.AST_NODE_TYPES.VariableDeclarator) {
-    return { pattern: node.id, source: node.init };
+  if (node.type === import_utils6.TSESTree.AST_NODE_TYPES.VariableDeclarator) {
+    const variableParts = {
+      pattern: node.id,
+      source: node.init
+    };
+    return variableParts;
   }
   if (node.operator === "=") {
-    return { pattern: node.left, source: node.right };
+    const assignmentParts = {
+      pattern: node.left,
+      source: node.right
+    };
+    return assignmentParts;
   }
   return null;
 };
 var propertyName = (property) => {
-  if (property.type !== import_utils3.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+  if (property.type !== import_utils6.TSESTree.AST_NODE_TYPES.Property || property.computed) {
     return null;
   }
-  if (property.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (property.key.type === import_utils6.TSESTree.AST_NODE_TYPES.Identifier) {
     return property.key.name;
   }
-  return property.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
+  const { value } = property.key;
+  if (typeof value !== "string") return null;
+  return value;
 };
 var destructuredThisReads = (node) => {
   const parts = destructuringParts(node);
-  if (!parts || parts.pattern.type !== import_utils3.TSESTree.AST_NODE_TYPES.ObjectPattern || !isThisExpression(parts.source)) {
+  if (!parts) return void 0;
+  if (parts.pattern.type !== import_utils6.TSESTree.AST_NODE_TYPES.ObjectPattern) {
     return void 0;
   }
+  const isThisSource = isThisExpression(parts.source);
+  if (!isThisSource) return void 0;
   const reads = [];
   for (const property of parts.pattern.properties) {
     const name = propertyName(property);
-    if (name === null) {
-      return null;
-    }
+    if (name === null) return null;
     reads.push(name);
   }
   return reads;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
-var createRule = import_utils4.ESLintUtils.RuleCreator(
-  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
-);
-var enterClass = (node, classes, stack, thisStack) => {
-  const entry = {
-    node,
-    reads: /* @__PURE__ */ new Set()
-  };
-  classes.push(entry);
-  stack.push(entry);
-  thisStack.push(true);
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-lexical-this.ts
+var import_utils7 = require("@typescript-eslint/utils");
+var componentThis = (node, thisStack) => {
+  if (node.type === import_utils7.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
+    return thisStack.at(-1) ?? false;
+  }
+  const { parent } = node;
+  if (parent.type !== import_utils7.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  return !parent.static;
 };
-var componentThis = (node, thisStack) => node.type === import_utils4.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ? thisStack.at(-1) ?? false : node.parent.type === import_utils4.TSESTree.AST_NODE_TYPES.MethodDefinition && !node.parent.static;
-var trackMemberRead = (node, stack, thisStack, dynamicClasses) => {
-  const current = stack.at(-1);
-  if (!current || !thisStack.at(-1)) {
-    return;
-  }
-  const receiverIsThis = isThisExpression(node.object);
-  if (node.computed && receiverIsThis) {
-    dynamicClasses.add(current);
+var lexicalThisVisitor = (thisStack) => {
+  const listeners = {
+    FunctionDeclaration(node) {
+      thisStack.push(componentThis(node, thisStack));
+    },
+    FunctionExpression(node) {
+      thisStack.push(componentThis(node, thisStack));
+    },
+    ArrowFunctionExpression(node) {
+      thisStack.push(componentThis(node, thisStack));
+    },
+    "FunctionDeclaration:exit"() {
+      thisStack.pop();
+    },
+    "FunctionExpression:exit"() {
+      thisStack.pop();
+    },
+    "ArrowFunctionExpression:exit"() {
+      thisStack.pop();
+    },
+    StaticBlock() {
+      thisStack.push(false);
+    },
+    "StaticBlock:exit"() {
+      thisStack.pop();
+    },
+    PropertyDefinition(node) {
+      if (node.static) {
+        thisStack.push(false);
+      }
+    },
+    "PropertyDefinition:exit"(node) {
+      if (node.static) {
+        thisStack.pop();
+      }
+    }
+  };
+  return listeners;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-write-targets.ts
+var import_utils8 = require("@typescript-eslint/utils");
+var parentOf = (node) => {
+  if (node.type === import_utils8.TSESTree.AST_NODE_TYPES.Program) return void 0;
+  return node.parent;
+};
+var isPatternTarget = (parent, child) => {
+  if (parent === void 0) return false;
+  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ArrayPattern) {
+    return parent.elements.some((element) => element === child);
+  }
+  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
+    return parent.left === child;
+  }
+  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ObjectPattern) {
+    return parent.properties.some((property) => property === child);
+  }
+  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.Property) {
+    const isObjectPattern = parent.parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ObjectPattern;
+    return parent.value === child && isObjectPattern;
+  }
+  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.RestElement) {
+    return parent.argument === child;
+  }
+  return false;
+};
+var isSimpleAssignmentTarget = (parent, current) => {
+  if (parent?.type !== import_utils8.TSESTree.AST_NODE_TYPES.AssignmentExpression) {
+    return false;
+  }
+  return parent.left === current && parent.operator === "=";
+};
+var isLoopTarget = (parent, current) => {
+  const isForIn = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.ForInStatement;
+  const isForOf = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.ForOfStatement;
+  const isLoop = isForIn || isForOf;
+  if (!isLoop) return false;
+  return parent.left === current;
+};
+var isWrapping = (parent, child) => {
+  const isWrapper = isTypeScriptExpressionWrapper(parent);
+  if (!isWrapper) return false;
+  return parent.expression === child;
+};
+var isDirectWrite = (node) => {
+  let current = node;
+  let parent = parentOf(node);
+  while (parent && isTypeScriptExpressionWrapper(parent) && parent.expression === current) {
+    current = parent;
+    parent = parentOf(parent);
+  }
+  const isDeleteExpression2 = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
+  const isAssignment = isSimpleAssignmentTarget(parent, current);
+  return isAssignment || isDeleteExpression2;
+};
+var isDestructuringOrLoopTarget = (node) => {
+  let current = node;
+  let parent = parentOf(node);
+  let patternTarget = false;
+  while (parent) {
+    const wrapper = isWrapping(parent, current);
+    const pattern = isPatternTarget(parent, current);
+    if (!wrapper && !pattern) break;
+    if (pattern) {
+      patternTarget = true;
+    }
+    current = parent;
+    parent = parentOf(parent);
+  }
+  const isSimpleTarget = isSimpleAssignmentTarget(parent, current);
+  const isAssignedPattern = patternTarget && isSimpleTarget;
+  return isAssignedPattern || isLoopTarget(parent, current);
+};
+var isWriteOnly = (node) => {
+  const isWrite = isDirectWrite(node);
+  if (isWrite) return true;
+  return isDestructuringOrLoopTarget(node);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-class-read-visitor.ts
+var enterClass = (node, classes, stack, thisStack) => {
+  const entry = {
+    node,
+    reads: /* @__PURE__ */ new Set()
+  };
+  classes.push(entry);
+  stack.push(entry);
+  thisStack.push(true);
+};
+var trackMemberRead = (node, stack, thisStack, dynamicClasses) => {
+  const current = stack.at(-1);
+  const isComponentThis = thisStack.at(-1);
+  if (!current || !isComponentThis) return;
+  const receiverIsThis = isThisExpression(node.object);
+  if (node.computed && receiverIsThis) {
+    dynamicClasses.add(current);
   }
-  if (receiverIsThis && !node.computed && node.property.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier && !isWriteOnly(node)) {
+  if (!receiverIsThis || node.computed) return;
+  const isWriteOnlyTarget = isWriteOnly(node);
+  if (isWriteOnlyTarget) return;
+  if (node.property.type === import_utils9.TSESTree.AST_NODE_TYPES.Identifier) {
     current.reads.add(node.property.name);
   }
 };
 var trackDestructuringRead = (node, stack, thisStack, dynamicClasses) => {
   const current = stack.at(-1);
-  if (!current || !thisStack.at(-1)) {
-    return;
-  }
+  const isComponentThis = thisStack.at(-1);
+  if (!current || !isComponentThis) return;
   const reads = destructuredThisReads(node);
-  if (reads === void 0) {
-    return;
-  }
+  if (reads === void 0) return;
   if (reads === null) {
     dynamicClasses.add(current);
     return;
@@ -597,45 +910,9 @@ var trackDestructuringRead = (node, stack, thisStack, dynamicClasses) => {
     current.reads.add(name);
   }
 };
-var lexicalThisVisitor = (thisStack) => ({
-  FunctionDeclaration(node) {
-    thisStack.push(componentThis(node, thisStack));
-  },
-  FunctionExpression(node) {
-    thisStack.push(componentThis(node, thisStack));
-  },
-  ArrowFunctionExpression(node) {
-    thisStack.push(componentThis(node, thisStack));
-  },
-  "FunctionDeclaration:exit"() {
-    thisStack.pop();
-  },
-  "FunctionExpression:exit"() {
-    thisStack.pop();
-  },
-  "ArrowFunctionExpression:exit"() {
-    thisStack.pop();
-  },
-  StaticBlock() {
-    thisStack.push(false);
-  },
-  "StaticBlock:exit"() {
-    thisStack.pop();
-  },
-  PropertyDefinition(node) {
-    if (node.static) {
-      thisStack.push(false);
-    }
-  },
-  "PropertyDefinition:exit"(node) {
-    if (node.static) {
-      thisStack.pop();
-    }
-  }
-});
-var visitor = (context, imports, classes, stack, dynamicClasses) => {
+var classReadVisitor = (classes, stack, dynamicClasses) => {
   const thisStack = [];
-  return {
+  const listeners = {
     ClassDeclaration(node) {
       enterClass(node, classes, stack, thisStack);
     },
@@ -659,183 +936,1887 @@ var visitor = (context, imports, classes, stack, dynamicClasses) => {
     },
     VariableDeclarator(node) {
       trackDestructuringRead(node, stack, thisStack, dynamicClasses);
-    },
-    "Program:exit"() {
-      reportUnusedMembers(context, imports, classes, dynamicClasses);
     }
   };
+  return listeners;
 };
-var no_unused_angular_instance_fields_default = createRule({
-  name: "no-unused-instance-fields",
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow unread instance fields and methods in Angular components and directives"
-    },
-    messages: {
-      unusedField: "Angular instance field '{{name}}' is never read.",
-      unusedMethod: "Angular instance method '{{name}}' is never read."
-    },
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    const imports = /* @__PURE__ */ new Map();
-    for (const node of context.sourceCode.ast.body) {
-      if (node.type === import_utils4.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
-        addAngularImport(node, imports);
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
+var import_typescript17 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-directive-index.ts
+var import_compiler4 = require("@angular/compiler");
+var classShape = ({
+  component,
+  declaration,
+  exportAs,
+  hostDirectives,
+  name,
+  selector
+}) => {
+  const fields = [
+    declaration.getSourceFile().fileName,
+    name,
+    String(component),
+    String(hostDirectives),
+    selector ?? "",
+    exportAs.join(",")
+  ];
+  return fields.join("\0");
+};
+var directiveShape = (classes) => {
+  const shapes = [...classes].map(classShape);
+  return shapes.sort().join("\n");
+};
+var parseSelector = (selector) => {
+  try {
+    return import_compiler4.CssSelector.parse(selector);
+  } catch {
+    return null;
+  }
+};
+var buildDirectiveIndex = (classes) => {
+  const byDeclaration = /* @__PURE__ */ new Map();
+  const byExportAs = /* @__PURE__ */ new Map();
+  const componentMatcher = new import_compiler4.SelectorMatcher();
+  for (const angularClass2 of classes) {
+    const { component, declaration, exportAs, selector } = angularClass2;
+    byDeclaration.set(declaration, angularClass2);
+    for (const name of exportAs) {
+      const declarations = byExportAs.get(name) ?? [];
+      declarations.push(declaration);
+      byExportAs.set(name, declarations);
+    }
+    if (component && selector !== null) {
+      const selectors = parseSelector(selector);
+      if (selectors) {
+        componentMatcher.addSelectables(selectors, [declaration]);
       }
     }
-    if (imports.size === 0) {
-      return {};
+  }
+  const directiveIndex = {
+    byDeclaration,
+    byExportAs,
+    componentMatcher
+  };
+  return directiveIndex;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
+var import_node_fs2 = require("node:fs");
+var import_typescript3 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
+var import_compiler7 = require("@angular/compiler");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-resolved-path.ts
+var import_typescript2 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/type-property-symbols.util.ts
+var import_typescript = require("typescript");
+var symbolsForName = (checker, type, name) => {
+  const symbol = checker.getPropertyOfType(checker.getApparentType(type), name);
+  if (symbol) return [symbol];
+  const isUnionOrIntersection = type.isUnionOrIntersection();
+  if (!isUnionOrIntersection) return [];
+  const symbols = /* @__PURE__ */ new Set();
+  for (const member of type.types) {
+    for (const memberSymbol of symbolsForName(checker, member, name)) {
+      symbols.add(memberSymbol);
     }
-    const classes = [];
-    const stack = [];
-    const dynamicClasses = /* @__PURE__ */ new Set();
-    return visitor(context, imports, classes, stack, dynamicClasses);
   }
-});
+  return [...symbols];
+};
+var stringIndexTypes = (checker, type) => {
+  const indexedType = checker.getIndexTypeOfType(
+    checker.getApparentType(type),
+    import_typescript.IndexKind.String
+  );
+  if (indexedType) return [indexedType];
+  const isUnionOrIntersection = type.isUnionOrIntersection();
+  if (!isUnionOrIntersection) return [];
+  const indexedTypes = /* @__PURE__ */ new Set();
+  for (const member of type.types) {
+    for (const memberIndexedType of stringIndexTypes(checker, member)) {
+      indexedTypes.add(memberIndexedType);
+    }
+  }
+  return [...indexedTypes];
+};
 
-// packages/lint-suite/src/lib/angular.ts
-var lintSuiteAngularPlugin = {
-  rules: {
-    "no-unused-instance-fields": no_unused_angular_instance_fields_default
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-resolved-path.ts
+var hasAnyOrUnknownFlag = (type) => {
+  const anyOrUnknown = import_typescript2.TypeFlags.Any | import_typescript2.TypeFlags.Unknown;
+  return (type.flags & anyOrUnknown) !== 0;
+};
+var isAnyOrUnknown = (types) => {
+  return types.some(hasAnyOrUnknownFlag);
+};
+var addTypes = (sink, types) => {
+  for (const type of types) {
+    sink.addType(type);
   }
 };
-var angular = (0, import_config2.defineConfig)([
-  {
-    files: ["**/*.ts"],
-    extends: [...import_angular_eslint2.configs.tsRecommended],
-    plugins: {
-      "lint-suite-angular": lintSuiteAngularPlugin
-    },
-    languageOptions: {
-      globals: {
-        ...import_globals.default.browser,
-        ...import_globals.default.es2025,
-        ...import_globals.default.node
+var callReturnTypes = (checker, type) => {
+  const signatures = checker.getSignaturesOfType(type, import_typescript2.SignatureKind.Call);
+  return signatures.map((signature) => signature.getReturnType());
+};
+var memberTypes = (symbols, declaration, checker, sink) => {
+  const types = [];
+  for (const symbol of symbols) {
+    for (const memberDeclaration of symbol.declarations ?? []) {
+      sink.addDeclaration(memberDeclaration);
+    }
+    types.push(checker.getTypeOfSymbolAtLocation(symbol, declaration));
+  }
+  return types;
+};
+var addResolvedPath = ({
+  allowMissingRoot,
+  checker,
+  declaration,
+  names,
+  sink
+}) => {
+  let types = [checker.getTypeAtLocation(declaration)];
+  const indexTypesOf = (type) => stringIndexTypes(checker, type);
+  const returnTypesOf = (type) => callReturnTypes(checker, type);
+  for (const [index, segment] of names.entries()) {
+    addTypes(sink, types);
+    const symbolsOf = (type) => {
+      return symbolsForName(checker, type, segment.name);
+    };
+    const symbols = new Set(types.flatMap(symbolsOf));
+    if (symbols.size === 0) {
+      const indexedTypes = types.flatMap(indexTypesOf);
+      if (indexedTypes.length > 0) {
+        types = indexedTypes;
+        continue;
       }
-    },
-    processor: import_angular_eslint2.processInlineTemplates,
-    rules: {
-      "lint-suite-angular/no-unused-instance-fields": "error",
-      "@angular-eslint/prefer-on-push-component-change-detection": "error",
-      // v22: flags only explicit opt-out of OnPush (omission now means OnPush)
-      "@angular-eslint/prefer-signals": "error",
-      "@angular-eslint/use-injectable-provided-in": "error",
-      "@angular-eslint/prefer-signal-model": "error",
-      "@angular-eslint/no-uncalled-signals": "error",
-      "@angular-eslint/prefer-host-metadata-property": "error",
-      "@angular-eslint/no-implicit-take-until-destroyed": "error",
-      // v21.2.0: Enforce explicit DestroyRef
-      "@angular-eslint/no-async-lifecycle-method": "error",
-      // Prevent async lifecycle hooks
-      "@angular-eslint/prefer-output-readonly": "warn",
-      // Prevent accidental reassignment
-      "@angular-eslint/prefer-output-emitter-ref": "warn",
-      // Modern output() function over @Output()
-      "@angular-eslint/sort-lifecycle-methods": "warn",
-      // Consistent lifecycle method ordering
-      "@angular-eslint/computed-must-return": "error",
-      // Catch silent computed() bugs missing a return
-      "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
-      // Catch duplicate imports/providers in @Component/@NgModule
-      "@angular-eslint/no-lifecycle-call": "error",
-      // Forbid manual this.ngOnInit() calls
-      "@angular-eslint/require-lifecycle-on-prototype": "error",
-      // Lifecycle hooks must be methods, not arrow-fn fields
-      "@angular-eslint/relative-url-prefix": "error",
-      // Require ./ in templateUrl/styleUrl for portability
-      "@angular-eslint/use-component-selector": "error",
-      // All components must declare a selector
-      "@angular-eslint/no-developer-preview": "warn",
-      // Flag APIs marked @developerPreview (no breaking-change policy)
-      "@angular-eslint/no-experimental": "warn"
-      // Flag APIs marked @experimental
+      const isAnyOrUnknownType = isAnyOrUnknown(types);
+      if (isAnyOrUnknownType) return true;
+      return index === 0 && allowMissingRoot;
+    }
+    types = memberTypes(symbols, declaration, checker, sink);
+    if (segment.called) {
+      const returnTypes = types.flatMap(returnTypesOf);
+      if (returnTypes.length === 0) return isAnyOrUnknown(types);
+      types = returnTypes;
     }
   }
-]);
+  return true;
+};
 
-// packages/lint-suite/src/lib/base.ts
-var import_eslint_plugin = require("@nx/eslint-plugin");
-var import_eslint_plugin2 = __toESM(require("@stylistic/eslint-plugin"), 1);
-var import_eslint_plugin_import_x = __toESM(require("eslint-plugin-import-x"), 1);
-var import_config3 = require("eslint/config");
-var base = (0, import_config3.defineConfig)([
-  { extends: [...import_eslint_plugin.configs["flat/base"]] },
-  {
-    files: [
-      "**/*.js",
-      "**/*.jsx",
-      "**/*.cjs",
-      "**/*.mjs",
-      "**/*.ts",
-      "**/*.tsx",
-      "**/*.cts",
-      "**/*.mts"
-    ],
-    extends: [import_eslint_plugin_import_x.default.flatConfigs.recommended]
-  },
-  {
-    files: [
-      "**/*.js",
-      "**/*.jsx",
-      "**/*.cjs",
-      "**/*.mjs",
-      "**/*.ts",
-      "**/*.tsx",
-      "**/*.cts",
-      "**/*.mts"
-    ],
-    extends: [import_eslint_plugin2.default.configs.recommended]
-  },
-  {
-    files: [
-      "**/*.js",
-      "**/*.jsx",
-      "**/*.cjs",
-      "**/*.mjs",
-      "**/*.ts",
-      "**/*.tsx",
-      "**/*.cts",
-      "**/*.mts"
-    ],
-    rules: {
-      "no-param-reassign": "error",
-      "no-alert": "error",
-      "no-console": ["warn", { allow: ["warn", "error"] }],
-      "no-debugger": "error",
-      eqeqeq: ["error", "always", { null: "ignore" }],
-      curly: ["error", "multi"],
-      "prefer-const": ["error", { destructuring: "all" }],
-      "no-var": "error",
-      "object-shorthand": "error",
-      "prefer-arrow-callback": "error",
-      "no-useless-concat": "error",
-      "prefer-template": "error",
-      "no-nested-ternary": "error",
-      "no-useless-assignment": "error",
-      // NEW: Catch unused assignments (ESLint v9)
-      "no-object-constructor": "error",
-      // Disallow new Object() without arguments
-      "no-else-return": ["error", { allowElseIf: false }],
-      // Prefer early returns
-      "no-multi-assign": "error",
-      // Disallow chaining assignments
-      radix: "error",
-      // Require radix parameter for parseInt()
-      yoda: "error",
-      // Disallow yoda conditions (`if ("red" === color)`)
-      complexity: ["warn", 10],
-      // Warn if function complexity is high
-      "max-depth": ["warn", 4],
-      // Warn on deeply nested blocks
-      "max-lines-per-function": [
-        "warn",
-        { max: 50, skipBlankLines: true, skipComments: true }
-      ],
-      // Warn on long functions
-      "max-params": ["warn", 4],
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-chains.ts
+var import_compiler5 = require("@angular/compiler");
+var isPropertyReadLike = (node) => {
+  const isPlainRead = node instanceof import_compiler5.PropertyRead;
+  const isSafeRead = node instanceof import_compiler5.SafePropertyRead;
+  return isPlainRead || isSafeRead;
+};
+var isRootRead = (read) => {
+  const isImplicitReceiver = read.receiver instanceof import_compiler5.ImplicitReceiver;
+  const isThisReceiver = read.receiver instanceof import_compiler5.ThisReceiver;
+  return isImplicitReceiver || isThisReceiver;
+};
+var chainStep = (read) => {
+  const receiver = read.receiver;
+  const isReadReceiver = isPropertyReadLike(receiver);
+  if (isReadReceiver) {
+    const readStep = { called: false, next: receiver };
+    return readStep;
+  }
+  const isCallReceiver = receiver instanceof import_compiler5.Call;
+  if (!isCallReceiver) return null;
+  const target = receiver.receiver;
+  const isReadLikeTarget = isPropertyReadLike(target);
+  if (!isReadLikeTarget) return null;
+  const calledStep = { called: true, next: target };
+  return calledStep;
+};
+var readChain = (node) => {
+  const leaf = { called: false, name: node.name };
+  const names = [leaf];
+  let current = node;
+  while (!isRootRead(current)) {
+    const step = chainStep(current);
+    if (step === null) return null;
+    current = step.next;
+    names.unshift({ called: step.called, name: current.name });
+  }
+  if (!(current instanceof import_compiler5.PropertyRead)) return null;
+  const chain = { names, root: current };
+  return chain;
+};
+var ReadCollector2 = class extends import_compiler5.CombinedRecursiveAstVisitor {
+  reads = [];
+  referenceOwners = /* @__PURE__ */ new Map();
+  record(node) {
+    const chain = readChain(node);
+    if (chain) {
+      this.reads.push(chain);
+    }
+  }
+  recordReferences(owner) {
+    for (const reference of owner.references) {
+      this.referenceOwners.set(reference, owner);
+    }
+  }
+  visitElement(element) {
+    this.recordReferences(element);
+    super.visitElement(element);
+  }
+  visitTemplate(template) {
+    this.recordReferences(template);
+    super.visitTemplate(template);
+  }
+  visitComponent(component) {
+    this.recordReferences(component);
+    super.visitComponent(component);
+  }
+  visitDirective(directive) {
+    this.recordReferences(directive);
+    super.visitDirective(directive);
+  }
+  visitBinary(node, context) {
+    if (node.operation !== "=") return super.visitBinary(node, context);
+    if (isReadTarget(node.left)) {
+      this.visit(node.left.receiver);
+    }
+    if (node.left instanceof import_compiler5.KeyedRead || node.left instanceof import_compiler5.SafeKeyedRead) {
+      this.visit(node.left.key);
+    }
+    this.visit(node.right);
+    return void 0;
+  }
+  visitPropertyRead(node, context) {
+    this.record(node);
+    return super.visitPropertyRead(node, context);
+  }
+  visitSafePropertyRead(node, context) {
+    this.record(node);
+    return super.visitSafePropertyRead(node, context);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-references.ts
+var import_compiler6 = require("@angular/compiler");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/read-chain-text.util.ts
+var segmentText = (segment) => {
+  const call = segment.called ? "()" : "";
+  return `${segment.name}${call}`;
+};
+var chainText = (names) => {
+  const texts = names.map(segmentText);
+  return texts.join(".");
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-references.ts
+var referenceTargets = (reference, owner, directives, scope) => {
+  const exportAs = reference.value.trim();
+  let targets = [];
+  if (exportAs !== "") {
+    const exportedTargets = directives.byExportAs.get(exportAs) ?? [];
+    targets = [...exportedTargets];
+  } else if (owner instanceof import_compiler6.TmplAstElement) {
+    directives.componentMatcher.match(
+      (0, import_compiler6.createCssSelectorFromNode)(owner),
+      (_selector, declarations) => {
+        targets.push(...declarations);
+      }
+    );
+  }
+  const scoped = scope !== null && !scope.some(
+    (declaration) => directives.byDeclaration.get(declaration)?.hostDirectives
+  );
+  if (!scoped) return targets;
+  const scopedTargets = targets.filter((target) => scope.includes(target));
+  return scopedTargets;
+};
+var addReferenceRead = (context, reference, owner, names) => {
+  const { checker, className, directives, fileName, scope, sink } = context;
+  const targets = referenceTargets(reference, owner, directives, scope);
+  const isTargetResolved = (target) => {
+    const options = {
+      allowMissingRoot: false,
+      checker,
+      declaration: target,
+      names,
+      sink
+    };
+    return addResolvedPath(options);
+  };
+  const resolved = targets.map(isTargetResolved);
+  const hasResolvedTarget = resolved.includes(true);
+  if (resolved.length === 0) return;
+  if (hasResolvedTarget) return;
+  const fallbackNames = names.map((segment) => segment.name);
+  const reason = `${fileName}: cannot resolve '#${reference.name}.${chainText(names)}' in ${className}`;
+  sink.addFallbackNames(fallbackNames, reason);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
+var identifierNames = (text2) => {
+  const matches = text2.match(/[A-Za-z_$][\w$]*/gu) ?? [];
+  return new Set(matches);
+};
+var templateBinder2 = new import_compiler7.R3TargetBinder(null);
+var unparsedTemplateReads = (context, source, error) => {
+  const names = identifierNames(source);
+  const message = error ?? "unknown error";
+  const reason = `${context.fileName}: template of ${context.className} does not parse (${message})`;
+  context.sink.addFallbackNames(names, reason);
+  const unparsedReads = { usedDirectiveIndex: false };
+  return unparsedReads;
+};
+var addComponentRead = (context, names) => {
+  const { checker, className, declaration, fileName, sink } = context;
+  const options = {
+    allowMissingRoot: true,
+    checker,
+    declaration,
+    names,
+    sink
+  };
+  const isResolved = addResolvedPath(options);
+  if (isResolved) return;
+  const fallbackNames = names.map((segment) => segment.name);
+  const reason = `${fileName}: cannot resolve '${chainText(names)}' on ${className}`;
+  sink.addFallbackNames(fallbackNames, reason);
+};
+var chainEntity = (boundTarget, chain) => {
+  const isThisRead = chain.root.receiver instanceof import_compiler7.ThisReceiver;
+  if (isThisRead) return null;
+  return boundTarget.getExpressionTarget(chain.root);
+};
+var addChainRead = (context, reads, boundTarget, chain) => {
+  const entity = chainEntity(boundTarget, chain);
+  if (entity === null) {
+    addComponentRead(context, chain.names);
+    return false;
+  }
+  if (!(entity instanceof import_compiler7.TmplAstReference)) return false;
+  const owner = reads.referenceOwners.get(entity);
+  const names = chain.names.slice(1);
+  addReferenceRead(context, entity, owner, names);
+  return true;
+};
+var addTemplateReads = ({
+  angularClass: angularClass2,
+  checker,
+  directives,
+  fileName,
+  sink,
+  source
+}) => {
+  const { declaration, scope } = angularClass2;
+  const className = declaration.name?.text ?? "(anonymous)";
+  const context = {
+    checker,
+    className,
+    declaration,
+    directives,
+    fileName,
+    scope,
+    sink
+  };
+  const parsed = (0, import_compiler7.parseTemplate)(source, fileName);
+  if (parsed.errors?.length) {
+    const error = parsed.errors[0]?.msg;
+    return unparsedTemplateReads(context, source, error);
+  }
+  const boundTarget = templateBinder2.bind({ template: parsed.nodes });
+  const reads = new ReadCollector2();
+  for (const node of parsed.nodes) {
+    reads.visit(node);
+  }
+  let usedDirectiveIndex = false;
+  for (const chain of reads.reads) {
+    const usedIndex = addChainRead(context, reads, boundTarget, chain);
+    usedDirectiveIndex ||= usedIndex;
+  }
+  const templateReads2 = { usedDirectiveIndex };
+  return templateReads2;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
+var memberNameOf = (member) => {
+  const name = member.name;
+  if (!name) return [];
+  const isIdentifierName = (0, import_typescript3.isIdentifier)(name);
+  const isStringName = (0, import_typescript3.isStringLiteralLike)(name);
+  const isTextName = isIdentifierName || isStringName;
+  if (!isTextName) return [];
+  const names = [name.text];
+  return names;
+};
+var memberNames = (declaration) => {
+  return declaration.members.flatMap(memberNameOf);
+};
+var unknownTemplateNames = ({ declaration, scope }, allNames) => {
+  if (scope === null) return allNames;
+  const scopeNames = scope.flatMap(memberNames);
+  const names = [...memberNames(declaration), ...scopeNames];
+  return names;
+};
+var templateFileVersion = (fileName) => {
+  const { mtimeNs, size } = (0, import_node_fs2.statSync)(fileName, { bigint: true });
+  const version = { fileName, mtimeNs, size };
+  return version;
+};
+var templateFileIsCurrent = (version) => {
+  try {
+    const current = (0, import_node_fs2.statSync)(version.fileName, { bigint: true });
+    return current.mtimeNs === version.mtimeNs && current.size === version.size;
+  } catch {
+    return false;
+  }
+};
+var templateSourceOf = (angularClass2, allNames, sink, versions) => {
+  const { declaration, template, valid } = angularClass2;
+  const fileName = declaration.getSourceFile().fileName;
+  const className = declaration.name?.text ?? "(anonymous)";
+  if (!valid) {
+    const names = unknownTemplateNames(angularClass2, allNames);
+    const reason = `${fileName}: metadata of ${className} is not static (template, templateUrl)`;
+    sink.addFallbackNames(names, reason);
+    return null;
+  }
+  if (!template) return null;
+  if (template.kind === "inline") {
+    const inlineSource = { fileName, source: template.source };
+    return inlineSource;
+  }
+  const templateFileName = template.fileName;
+  try {
+    versions.push(templateFileVersion(templateFileName));
+    const source = (0, import_node_fs2.readFileSync)(templateFileName, "utf8");
+    const externalSource = {
+      fileName: templateFileName,
+      source
+    };
+    return externalSource;
+  } catch {
+    const names = unknownTemplateNames(angularClass2, allNames);
+    const reason = `${fileName}: templateUrl of ${className} cannot be read (${templateFileName})`;
+    sink.addFallbackNames(names, reason);
+    return null;
+  }
+};
+var collectAngularTemplateReads = ({
+  allNames,
+  checker,
+  classes,
+  directives,
+  sink
+}) => {
+  const templateVersions = [];
+  let usedDirectiveIndex = false;
+  for (const angularClass2 of classes) {
+    const template = templateSourceOf(
+      angularClass2,
+      allNames,
+      sink,
+      templateVersions
+    );
+    if (template === null) continue;
+    const result = addTemplateReads({
+      angularClass: angularClass2,
+      checker,
+      directives,
+      fileName: template.fileName,
+      sink,
+      source: template.source
+    });
+    usedDirectiveIndex ||= result.usedDirectiveIndex;
+  }
+  const templateReads2 = {
+    templateVersions,
+    usedDirectiveIndex
+  };
+  return templateReads2;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
+var import_typescript10 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-angular-interface-methods.ts
+var import_typescript5 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-symbol-reads.ts
+var import_typescript4 = require("typescript");
+var aliasTarget = (checker, symbol) => {
+  const isAlias = (symbol.flags & import_typescript4.SymbolFlags.Alias) !== 0;
+  if (!isAlias) return symbol;
+  return checker.getAliasedSymbol(symbol);
+};
+var addSymbolDeclarations = (checker, symbol, sink) => {
+  const resolved = aliasTarget(checker, symbol);
+  for (const declaration of resolved.declarations ?? []) {
+    sink.addDeclaration(declaration);
+  }
+};
+var allPropertySymbols = (checker, type) => {
+  const symbols = new Set(
+    checker.getPropertiesOfType(checker.getApparentType(type))
+  );
+  const isUnionOrIntersection = type.isUnionOrIntersection();
+  if (isUnionOrIntersection) {
+    for (const member of type.types) {
+      for (const symbol of allPropertySymbols(checker, member)) {
+        symbols.add(symbol);
+      }
+    }
+  }
+  return [...symbols];
+};
+var namedPropertySymbols = (checker, type, names) => {
+  if (names === null) return allPropertySymbols(checker, type);
+  return names.flatMap((name) => symbolsForName(checker, type, name));
+};
+var addNamedProperties = (checker, type, names, sink) => {
+  sink.addType(type);
+  const symbols = namedPropertySymbols(checker, type, names);
+  for (const symbol of symbols) {
+    addSymbolDeclarations(checker, symbol, sink);
+  }
+  return symbols;
+};
+var literalPropertyNames = (type) => {
+  const isStringLiteral = type.isStringLiteral();
+  const isNumberLiteral = type.isNumberLiteral();
+  const isLiteralType = isStringLiteral || isNumberLiteral;
+  if (isLiteralType) return [String(type.value)];
+  const isUnion = type.isUnion();
+  if (!isUnion) return null;
+  const names = [];
+  for (const member of type.types) {
+    const memberNames2 = literalPropertyNames(member);
+    if (!memberNames2) return null;
+    names.push(...memberNames2);
+  }
+  return names;
+};
+var propertyName2 = (checker, node) => {
+  const isIdentifierName = (0, import_typescript4.isIdentifier)(node);
+  const isPrivateName = (0, import_typescript4.isPrivateIdentifier)(node);
+  const isStringName = (0, import_typescript4.isStringLiteralLike)(node);
+  const isNumericName = (0, import_typescript4.isNumericLiteral)(node);
+  const isBigIntName = (0, import_typescript4.isBigIntLiteral)(node);
+  const isLiteralName = isIdentifierName || isPrivateName || isStringName || isNumericName || isBigIntName;
+  if (isLiteralName) return [node.text];
+  return literalPropertyNames(checker.getTypeAtLocation(node.expression));
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-angular-interface-methods.ts
+var isAngularMethodSignature = (declaration) => {
+  const isMethod = (0, import_typescript5.isMethodSignature)(declaration);
+  if (!isMethod) return false;
+  const fileName = declaration.getSourceFile().fileName.replaceAll("\\", "/");
+  return fileName.includes("/node_modules/@angular/");
+};
+var isAngularInterfaceMethod = (symbol) => {
+  const declarations = symbol.declarations ?? [];
+  return declarations.some(isAngularMethodSignature);
+};
+var addImplementations = (heritageType, classType, checker, sink) => {
+  for (const interfaceMethod of heritageType.getProperties()) {
+    const isInterfaceMethod = isAngularInterfaceMethod(interfaceMethod);
+    if (!isInterfaceMethod) continue;
+    const implementation = classType.getProperty(interfaceMethod.name);
+    if (implementation) {
+      addSymbolDeclarations(checker, implementation, sink);
+    }
+  }
+};
+var collectAngularInterfaceMethods = (node, checker, sink) => {
+  const heritageClauses = node.heritageClauses ?? [];
+  const implementsClauses = heritageClauses.filter(
+    (clause) => clause.token === import_typescript5.SyntaxKind.ImplementsKeyword
+  );
+  if (implementsClauses.length === 0) return;
+  const classType = checker.getTypeAtLocation(node);
+  for (const clause of implementsClauses) {
+    for (const heritageType of clause.types) {
+      const type = checker.getTypeAtLocation(heritageType);
+      sink.addType(type);
+      addImplementations(type, classType, checker, sink);
+    }
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
+var import_typescript8 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-assignment-pattern-elements.ts
+var import_typescript6 = require("typescript");
+var nestedPattern = (expression) => {
+  const isArrayLiteral = (0, import_typescript6.isArrayLiteralExpression)(expression);
+  const isObjectLiteral = (0, import_typescript6.isObjectLiteralExpression)(expression);
+  const isNested = isArrayLiteral || isObjectLiteral;
+  if (!isNested) return null;
+  return expression;
+};
+var nestedPropertyPattern = (property) => {
+  const isAssignment = (0, import_typescript6.isPropertyAssignment)(property);
+  if (!isAssignment) return null;
+  return nestedPattern(property.initializer);
+};
+var arrayElementRead = (element, index) => {
+  const isOmitted = (0, import_typescript6.isOmittedExpression)(element);
+  if (isOmitted) return null;
+  const isRestElement = (0, import_typescript6.isSpreadElement)(element);
+  const indexNames = [String(index)];
+  const names = isRestElement ? null : indexNames;
+  const nested = nestedPattern(element);
+  const read = {
+    location: element,
+    names,
+    nested,
+    rest: false
+  };
+  return read;
+};
+var propertyRead = (property, checker) => {
+  const isRestProperty = (0, import_typescript6.isSpreadAssignment)(property);
+  if (isRestProperty) {
+    const restRead = {
+      location: property,
+      names: null,
+      nested: null,
+      rest: true
+    };
+    return restRead;
+  }
+  const read = {
+    location: property,
+    names: propertyName2(checker, property.name),
+    nested: nestedPropertyPattern(property),
+    rest: false
+  };
+  return read;
+};
+var assignmentPatternElements = (pattern, checker) => {
+  const isArrayPattern = (0, import_typescript6.isArrayLiteralExpression)(pattern);
+  if (isArrayPattern) {
+    const reads = [];
+    for (const [index, element] of pattern.elements.entries()) {
+      const read = arrayElementRead(element, index);
+      if (read !== null) {
+        reads.push(read);
+      }
+    }
+    return reads;
+  }
+  return pattern.properties.map((property) => propertyRead(property, checker));
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-binding-pattern-elements.ts
+var import_typescript7 = require("typescript");
+var isBindingPattern = (node) => {
+  const isArrayPattern = (0, import_typescript7.isArrayBindingPattern)(node);
+  const isObjectPattern = (0, import_typescript7.isObjectBindingPattern)(node);
+  return isArrayPattern || isObjectPattern;
+};
+var nestedPattern2 = (element) => {
+  const isNested = isBindingPattern(element.name);
+  if (!isNested) return null;
+  return element.name;
+};
+var bindingNames = (checker, element) => {
+  if (element.propertyName) return propertyName2(checker, element.propertyName);
+  const isIdentifierName = (0, import_typescript7.isIdentifier)(element.name);
+  if (!isIdentifierName) return null;
+  return [element.name.text];
+};
+var arrayElementRead2 = (element, index) => {
+  const isOmitted = (0, import_typescript7.isOmittedExpression)(element);
+  if (isOmitted) return null;
+  const isRestElement = Boolean(element.dotDotDotToken);
+  const indexNames = [String(index)];
+  const names = isRestElement ? null : indexNames;
+  const nested = nestedPattern2(element);
+  const read = {
+    location: element,
+    names,
+    nested,
+    rest: false
+  };
+  return read;
+};
+var objectElementRead = (element, checker) => {
+  const isRestElement = Boolean(element.dotDotDotToken);
+  if (isRestElement) {
+    const restRead = {
+      location: element,
+      names: null,
+      nested: null,
+      rest: true
+    };
+    return restRead;
+  }
+  const read = {
+    location: element,
+    names: bindingNames(checker, element),
+    nested: nestedPattern2(element),
+    rest: false
+  };
+  return read;
+};
+var bindingPatternElements = (pattern, checker) => {
+  const isArrayPattern = (0, import_typescript7.isArrayBindingPattern)(pattern);
+  if (isArrayPattern) {
+    const reads = [];
+    for (const [index, element] of pattern.elements.entries()) {
+      const read = arrayElementRead2(element, index);
+      if (read !== null) {
+        reads.push(read);
+      }
+    }
+    return reads;
+  }
+  return pattern.elements.map((element) => objectElementRead(element, checker));
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
+var lazyType = (compute) => {
+  let type;
+  return () => type ??= compute();
+};
+var isSkippable = (read, candidateNames) => {
+  if (read.nested !== null) return false;
+  if (read.names === null) return false;
+  const hasCandidateName = read.names.some((name) => candidateNames.has(name));
+  return !hasCandidateName;
+};
+var patternElements = (pattern, checker) => {
+  const isBinding = isBindingPattern(pattern);
+  if (isBinding) return bindingPatternElements(pattern, checker);
+  return assignmentPatternElements(pattern, checker);
+};
+var addRestReads = (type, consumed, context) => {
+  context.sink.addType(type);
+  for (const symbol of allPropertySymbols(context.checker, type)) {
+    const isConsumed = consumed.has(symbol.name);
+    if (isConsumed) continue;
+    addSymbolDeclarations(context.checker, symbol, context.sink);
+  }
+};
+var collectPatternReads = (pattern, type, context) => {
+  const { checker, sink, candidateNames } = context;
+  const consumed = /* @__PURE__ */ new Set();
+  const reads = patternElements(pattern, checker);
+  for (const read of reads) {
+    if (read.rest) {
+      addRestReads(type(), consumed, context);
+      continue;
+    }
+    for (const name of read.names ?? []) {
+      consumed.add(name);
+    }
+    const skip = isSkippable(read, candidateNames);
+    if (skip) continue;
+    const symbols = addNamedProperties(checker, type(), read.names, sink);
+    const nested = read.nested;
+    if (nested === null) continue;
+    for (const symbol of symbols) {
+      const nestedType = lazyType(() => {
+        return checker.getTypeOfSymbolAtLocation(symbol, read.location);
+      });
+      collectPatternReads(nested, nestedType, context);
+    }
+  }
+};
+var collectBindingReads = (node, context) => {
+  const isBinding = isBindingPattern(node);
+  if (!isBinding) return;
+  const isBindingElementParent = (0, import_typescript8.isBindingElement)(node.parent);
+  const isNestedBindingName = isBindingElementParent && node.parent.name === node;
+  if (isNestedBindingName) return;
+  const declaration = node.parent;
+  const isDeclaration = (0, import_typescript8.isVariableDeclaration)(declaration);
+  const isInitializedDeclaration = isDeclaration && declaration.initializer !== void 0;
+  const source = isInitializedDeclaration ? declaration.initializer : declaration;
+  const sourceTypeOf = () => context.checker.getTypeAtLocation(source);
+  const sourceType = lazyType(sourceTypeOf);
+  collectPatternReads(node, sourceType, context);
+};
+var collectAssignmentReads = (node, context) => {
+  const isBinary = (0, import_typescript8.isBinaryExpression)(node);
+  if (!isBinary) return;
+  const isEqualsAssignment = node.operatorToken.kind === import_typescript8.SyntaxKind.EqualsToken;
+  if (!isEqualsAssignment) return;
+  const isArrayTarget = (0, import_typescript8.isArrayLiteralExpression)(node.left);
+  const isObjectTarget = (0, import_typescript8.isObjectLiteralExpression)(node.left);
+  const isDestructuringAssignment = isArrayTarget || isObjectTarget;
+  if (!isDestructuringAssignment) return;
+  const rightTypeOf = () => context.checker.getTypeAtLocation(node.right);
+  const sourceType = lazyType(rightTypeOf);
+  collectPatternReads(node.left, sourceType, context);
+};
+var collectDestructuringReads = (node, checker, sink, candidateNames) => {
+  const context = { checker, sink, candidateNames };
+  collectBindingReads(node, context);
+  collectAssignmentReads(node, context);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-write-targets.ts
+var import_typescript9 = require("typescript");
+var isExpressionWrapper = (parent, child) => {
+  const isParenthesized = (0, import_typescript9.isParenthesizedExpression)(parent);
+  const isAs = (0, import_typescript9.isAsExpression)(parent);
+  const isTypeAssertion = (0, import_typescript9.isTypeAssertionExpression)(parent);
+  const isNonNull = (0, import_typescript9.isNonNullExpression)(parent);
+  const isSatisfies = (0, import_typescript9.isSatisfiesExpression)(parent);
+  const isCast = isAs || isTypeAssertion || isSatisfies;
+  const isWrapper = isParenthesized || isNonNull || isCast;
+  if (!isWrapper) return false;
+  return parent.expression === child;
+};
+var isPatternContainer = (parent, child) => {
+  const isArrayLiteral = (0, import_typescript9.isArrayLiteralExpression)(parent);
+  if (isArrayLiteral) {
+    return parent.elements.some((element) => element === child);
+  }
+  const isObjectLiteral = (0, import_typescript9.isObjectLiteralExpression)(parent);
+  if (isObjectLiteral) {
+    return parent.properties.some((property) => property === child);
+  }
+  const isAssignment = (0, import_typescript9.isPropertyAssignment)(parent);
+  if (isAssignment) return parent.initializer === child;
+  const isSpread = (0, import_typescript9.isSpreadAssignment)(parent);
+  if (!isSpread) return false;
+  return parent.expression === child;
+};
+var isWriteTarget = (parent, current) => {
+  const isBinary = (0, import_typescript9.isBinaryExpression)(parent);
+  const isBinaryTarget = isBinary && parent.left === current && parent.operatorToken.kind === import_typescript9.SyntaxKind.EqualsToken;
+  if (isBinaryTarget) return true;
+  const isDelete = (0, import_typescript9.isDeleteExpression)(parent);
+  const isDeleteTarget = isDelete && parent.expression === current;
+  if (isDeleteTarget) return true;
+  const isForIn = (0, import_typescript9.isForInStatement)(parent);
+  const isForOf = (0, import_typescript9.isForOfStatement)(parent);
+  const isIteration = isForIn || isForOf;
+  return isIteration && parent.initializer === current;
+};
+var isWriteOnly2 = (node) => {
+  let current = node;
+  let parent = node.parent;
+  while (isExpressionWrapper(parent, current) || isPatternContainer(parent, current)) {
+    current = parent;
+    parent = parent.parent;
+  }
+  return isWriteTarget(parent, current);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
+var addPropertyAccessRead = (node, checker, sink, candidateNames) => {
+  const isCandidateName = candidateNames.has(node.name.text);
+  if (!isCandidateName) return;
+  const isWriteTarget2 = isWriteOnly2(node);
+  if (isWriteTarget2) return;
+  sink.addType(checker.getTypeAtLocation(node.expression));
+  const symbol = checker.getSymbolAtLocation(node.name);
+  if (symbol) {
+    addSymbolDeclarations(checker, symbol, sink);
+  }
+};
+var addElementAccessRead = (node, checker, sink, candidateNames) => {
+  const isWriteTarget2 = isWriteOnly2(node);
+  if (isWriteTarget2) return;
+  const argumentType = checker.getTypeAtLocation(node.argumentExpression);
+  const names = literalPropertyNames(argumentType);
+  if (names) {
+    const hasCandidateName = names.some((name) => candidateNames.has(name));
+    if (!hasCandidateName) return;
+  }
+  const targetType = checker.getTypeAtLocation(node.expression);
+  addNamedProperties(checker, targetType, names, sink);
+};
+var collectTypeScriptReads = (sourceFile, checker, sink, candidateNames) => {
+  const visit = (node) => {
+    const isPropertyAccess = (0, import_typescript10.isPropertyAccessExpression)(node);
+    const isElementAccess = (0, import_typescript10.isElementAccessExpression)(node);
+    const isClass = (0, import_typescript10.isClassLike)(node);
+    if (isPropertyAccess) {
+      addPropertyAccessRead(node, checker, sink, candidateNames);
+    } else if (isElementAccess) {
+      addElementAccessRead(node, checker, sink, candidateNames);
+    } else if (isClass) {
+      collectAngularInterfaceMethods(node, checker, sink);
+    }
+    collectDestructuringReads(node, checker, sink, candidateNames);
+    (0, import_typescript10.forEachChild)(node, visit);
+  };
+  visit(sourceFile);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-type-dependencies.ts
+var import_typescript11 = require("typescript");
+var isObjectType = (type) => {
+  return (type.flags & import_typescript11.TypeFlags.Object) !== 0;
+};
+var isTypeReference = (type) => {
+  return (type.objectFlags & import_typescript11.ObjectFlags.Reference) !== 0;
+};
+var isInterfaceType = (type) => {
+  return (type.objectFlags & import_typescript11.ObjectFlags.ClassOrInterface) !== 0;
+};
+var addDeclarationFiles = (type, dependencies) => {
+  for (const symbol of [type.getSymbol(), type.aliasSymbol]) {
+    const declarations = symbol?.declarations ?? [];
+    for (const declaration of declarations) {
+      dependencies.add(declaration.getSourceFile());
+    }
+  }
+};
+var baseTypesOf = (checker, type) => {
+  const isObject = isObjectType(type);
+  if (!isObject) return [];
+  const isReference = isTypeReference(type);
+  const target = isReference ? type.target : type;
+  const isClassOrInterface = isInterfaceType(target);
+  if (!isClassOrInterface) return [];
+  return checker.getBaseTypes(target);
+};
+var addTypeDependencies = (checker, type, dependencies, seen) => {
+  const isSeen = seen.has(type);
+  if (isSeen) return;
+  seen.add(type);
+  const isUnionOrIntersection = type.isUnionOrIntersection();
+  if (isUnionOrIntersection) {
+    for (const member of type.types) {
+      addTypeDependencies(checker, member, dependencies, seen);
+    }
+    return;
+  }
+  addDeclarationFiles(type, dependencies);
+  const isTypeParameter = (type.flags & import_typescript11.TypeFlags.TypeParameter) !== 0;
+  if (isTypeParameter) {
+    const constraint = checker.getBaseConstraintOfType(type);
+    if (constraint) {
+      addTypeDependencies(checker, constraint, dependencies, seen);
+    }
+    return;
+  }
+  for (const base2 of baseTypesOf(checker, type)) {
+    addTypeDependencies(checker, base2, dependencies, seen);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-file-entry.ts
+var failureText = (error) => {
+  if (error instanceof Error) return error.message;
+  return String(error);
+};
+var collectFileReads = (index, sourceFile, checker, sink) => {
+  try {
+    collectTypeScriptReads(sourceFile, checker, sink, index.candidateNames);
+    const classes = index.classes.get(sourceFile.fileName)?.classes ?? [];
+    return collectAngularTemplateReads({
+      allNames: index.candidateNames,
+      checker,
+      classes,
+      directives: index.directives,
+      sink
+    });
+  } catch (error) {
+    const errorMessage = failureText(error);
+    sink.addFallbackNames(
+      index.candidateNames,
+      `${sourceFile.fileName}: indexing failed (${errorMessage})`
+    );
+    const noTemplateReads = {
+      templateVersions: [],
+      usedDirectiveIndex: false
+    };
+    return noTemplateReads;
+  }
+};
+var computeEntry = (index, sourceFile, checker) => {
+  const declarations = /* @__PURE__ */ new Set();
+  const dependencies = /* @__PURE__ */ new Set();
+  const fallbackNames = /* @__PURE__ */ new Set();
+  const seenTypes = /* @__PURE__ */ new Set();
+  const sink = {
+    addDeclaration: (declaration) => {
+      declarations.add(declaration);
+      dependencies.add(declaration.getSourceFile());
+    },
+    addFallbackNames: (names) => {
+      for (const name of names) {
+        fallbackNames.add(name);
+      }
+    },
+    addType: (type) => {
+      addTypeDependencies(checker, type, dependencies, seenTypes);
+    }
+  };
+  const reads = collectFileReads(index, sourceFile, checker, sink);
+  dependencies.delete(sourceFile);
+  const fileEntry = {
+    ...reads,
+    declarations,
+    dependencies,
+    fallbackNames,
+    sourceFile
+  };
+  return fileEntry;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-discovery.ts
+var import_typescript15 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
+var import_typescript14 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-decorator-kind.ts
+var import_typescript12 = require("typescript");
+var decoratorKinds = [
+  "Component",
+  "Directive",
+  "NgModule",
+  "Pipe"
+];
+var isDecoratorKind = (name) => {
+  return decoratorKinds.some((kind) => kind === name);
+};
+var isAngularCoreFile = (declaration) => {
+  const fileName = declaration.getSourceFile().fileName.replaceAll("\\", "/");
+  return fileName.includes("/node_modules/@angular/core/");
+};
+var parentOf2 = (node) => {
+  return node.parent;
+};
+var importedFromAngularCore = (declaration) => {
+  let current = parentOf2(declaration);
+  while (current) {
+    if ((0, import_typescript12.isImportDeclaration)(current)) {
+      return (0, import_typescript12.isStringLiteralLike)(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
+    }
+    current = parentOf2(current);
+  }
+  return false;
+};
+var resolveAlias = (symbol, discovery) => {
+  let current = symbol;
+  for (let hop = 0; hop < 32; hop += 1) {
+    for (const declaration of current.declarations ?? []) {
+      discovery.dependencies.add(declaration.getSourceFile());
+    }
+    if ((current.flags & import_typescript12.SymbolFlags.Alias) === 0) return current;
+    const next = discovery.checker.getImmediateAliasedSymbol(current);
+    if (!next || next === current) return current;
+    current = next;
+  }
+  return current;
+};
+var angularDecoratorKind = (expression, discovery) => {
+  const unresolved = discovery.checker.getSymbolAtLocation(expression);
+  if (!unresolved) return null;
+  const symbol = resolveAlias(unresolved, discovery);
+  const name = symbol.getName();
+  const isKind = isDecoratorKind(name);
+  if (!isKind) return null;
+  const unresolvedDeclarations = unresolved.declarations ?? [];
+  const symbolDeclarations = symbol.declarations ?? [];
+  const isCoreImport = unresolvedDeclarations.some(importedFromAngularCore);
+  const isCoreDeclaration = symbolDeclarations.some(isAngularCoreFile);
+  const fromAngularCore = isCoreImport || isCoreDeclaration;
+  if (!fromAngularCore) return null;
+  return name;
+};
+var classDecoratorKind = (declaration, discovery) => {
+  const hasDecorators = (0, import_typescript12.canHaveDecorators)(declaration);
+  if (!hasDecorators) return null;
+  for (const decorator of (0, import_typescript12.getDecorators)(declaration) ?? []) {
+    const isDecoratorCall = (0, import_typescript12.isCallExpression)(decorator.expression);
+    if (!isDecoratorCall) continue;
+    const kind = angularDecoratorKind(
+      decorator.expression.expression,
+      discovery
+    );
+    if (kind !== null) return kind;
+  }
+  return null;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-metadata-values.ts
+var import_node_path2 = require("node:path");
+var import_typescript13 = require("typescript");
+var stringValue = (node, discovery) => {
+  if (!node) return null;
+  const isStringLiteral = (0, import_typescript13.isStringLiteralLike)(node);
+  if (isStringLiteral) return node.text;
+  const isIdentifierNode = (0, import_typescript13.isIdentifier)(node);
+  const isPropertyAccessNode = (0, import_typescript13.isPropertyAccessExpression)(node);
+  if (isIdentifierNode || isPropertyAccessNode) {
+    const symbol = discovery.checker.getSymbolAtLocation(
+      (0, import_typescript13.isIdentifier)(node) ? node : node.name
+    );
+    if (symbol) {
+      resolveAlias(symbol, discovery);
+    }
+  }
+  const type = discovery.checker.getTypeAtLocation(node);
+  return type.isStringLiteral() ? type.value : null;
+};
+var metadataProperty = (metadata, name) => {
+  for (const property of metadata.properties) {
+    const isAssignment = (0, import_typescript13.isPropertyAssignment)(property);
+    if (!isAssignment) continue;
+    const isIdentifierName = (0, import_typescript13.isIdentifier)(property.name);
+    const isStringName = (0, import_typescript13.isStringLiteralLike)(property.name);
+    const isNumericName = (0, import_typescript13.isNumericLiteral)(property.name);
+    const isLiteralName = isIdentifierName || isStringName || isNumericName;
+    const isPropertyNamed = isLiteralName && property.name.text === name;
+    if (isPropertyNamed) return property.initializer;
+  }
+  return void 0;
+};
+var templateOf = (metadata, fileName, discovery) => {
+  const inline = metadataProperty(metadata, "template");
+  if (inline) {
+    const source = stringValue(inline, discovery);
+    if (source === null) return void 0;
+    const inlineTemplate = { kind: "inline", source };
+    return inlineTemplate;
+  }
+  const url = metadataProperty(metadata, "templateUrl");
+  if (url) {
+    const text2 = stringValue(url, discovery);
+    if (text2 === null) return void 0;
+    const externalFileName = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(fileName), text2);
+    const externalTemplate = {
+      fileName: externalFileName,
+      kind: "external"
+    };
+    return externalTemplate;
+  }
+  return null;
+};
+var exportAsOf = (metadata, discovery) => {
+  const exportAsProperty = metadataProperty(metadata, "exportAs");
+  const exportAs = stringValue(exportAsProperty, discovery) ?? "";
+  const names = exportAs.split(",").map((name) => name.trim());
+  return names.filter(Boolean);
+};
+
+// 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 === import_typescript14.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === import_typescript14.SyntaxKind.FalseKeyword) return false;
+  return void 0;
+};
+var classesOf = (symbol, discovery) => {
+  const resolved = resolveAlias(symbol, discovery);
+  const declarations = resolved.declarations ?? [];
+  return declarations.filter(import_typescript14.isClassLike);
+};
+var scopedClasses = (classes, discovery) => {
+  const scoped = [];
+  for (const declaration of classes) {
+    if (declaration.getSourceFile().isDeclarationFile) continue;
+    const kind = classDecoratorKind(declaration, discovery);
+    if (kind === "Pipe") continue;
+    if (kind !== "Component" && kind !== "Directive") return null;
+    scoped.push(declaration);
+  }
+  return scoped;
+};
+var importedClasses = (element, discovery) => {
+  const isIdentifierElement = (0, import_typescript14.isIdentifier)(element);
+  const isPropertyAccessElement = (0, import_typescript14.isPropertyAccessExpression)(element);
+  if (!isIdentifierElement && !isPropertyAccessElement) return null;
+  const target = isIdentifierElement ? element : element.name;
+  const symbol = discovery.checker.getSymbolAtLocation(target);
+  if (!symbol) return null;
+  const classes = classesOf(symbol, discovery);
+  if (classes.length === 0) return null;
+  return scopedClasses(classes, discovery);
+};
+var scopeOf = (metadata, discovery) => {
+  const standalone = booleanValue(metadataProperty(metadata, "standalone"));
+  const imports = metadataProperty(metadata, "imports");
+  const isModuleDeclared = standalone === void 0 && !imports;
+  if (standalone === false || isModuleDeclared) return null;
+  if (!imports) return [];
+  const isImportsArray = (0, import_typescript14.isArrayLiteralExpression)(imports);
+  if (!isImportsArray) return null;
+  const scope = [];
+  for (const element of imports.elements) {
+    const classes = importedClasses(element, discovery);
+    if (classes === null) return null;
+    scope.push(...classes);
+  }
+  return scope;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-discovery.ts
+var describedClass = (base2, metadata, discovery) => {
+  const selector = metadataProperty(metadata, "selector");
+  const described = {
+    ...base2,
+    exportAs: exportAsOf(metadata, discovery),
+    hostDirectives: metadataProperty(metadata, "hostDirectives") !== void 0,
+    selector: stringValue(selector, discovery)
+  };
+  if (!base2.component) {
+    const directiveDiscovery = { ...described, valid: true };
+    return directiveDiscovery;
+  }
+  const fileName = base2.declaration.getSourceFile().fileName;
+  const template = templateOf(metadata, fileName, discovery);
+  const componentDiscovery = {
+    ...described,
+    scope: scopeOf(metadata, discovery),
+    template: template ?? null,
+    valid: template !== void 0
+  };
+  return componentDiscovery;
+};
+var decoratedClass = (declaration, call, discovery) => {
+  const kind = angularDecoratorKind(call.expression, discovery);
+  if (kind !== "Component" && kind !== "Directive") return null;
+  const component = kind === "Component";
+  const base2 = {
+    component,
+    declaration,
+    exportAs: [],
+    hostDirectives: false,
+    name: declaration.name?.text ?? "",
+    scope: null,
+    selector: null,
+    template: null
+  };
+  const metadata = call.arguments.at(0);
+  if (metadata === void 0) {
+    const bareDiscovery = { ...base2, valid: !component };
+    return bareDiscovery;
+  }
+  const isMetadataObject = (0, import_typescript15.isObjectLiteralExpression)(metadata);
+  if (!isMetadataObject) {
+    const invalidDiscovery = { ...base2, valid: false };
+    return invalidDiscovery;
+  }
+  return describedClass(base2, metadata, discovery);
+};
+var angularClass = (declaration, discovery) => {
+  const hasDecorators = (0, import_typescript15.canHaveDecorators)(declaration);
+  if (!hasDecorators) return null;
+  for (const decorator of (0, import_typescript15.getDecorators)(declaration) ?? []) {
+    const isDecoratorCall = (0, import_typescript15.isCallExpression)(decorator.expression);
+    if (!isDecoratorCall) continue;
+    const found = decoratedClass(declaration, decorator.expression, discovery);
+    if (found) return found;
+  }
+  return null;
+};
+var angularClasses = (sourceFile, checker) => {
+  const classes = [];
+  const discovery = { checker, dependencies: /* @__PURE__ */ new Set() };
+  const visit = (node) => {
+    const isClass = (0, import_typescript15.isClassLike)(node);
+    if (isClass) {
+      const found = angularClass(node, discovery);
+      if (found) {
+        classes.push(found);
+      }
+    }
+    (0, import_typescript15.forEachChild)(node, visit);
+  };
+  visit(sourceFile);
+  discovery.dependencies.delete(sourceFile);
+  const discovered = {
+    classes,
+    dependencies: discovery.dependencies
+  };
+  return discovered;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/spec-file.util.ts
+var specFilePattern = /\.spec\.[cm]?[tj]sx?$/u;
+var isSpecFile = (fileName) => {
+  return specFilePattern.test(fileName);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-staleness.ts
+var typeScriptFilePattern = /\.(?:[cm]?ts|tsx)$/u;
+var isIndexable = (program, sourceFile) => {
+  if (sourceFile.isDeclarationFile) return false;
+  const isExternal = program.isSourceFileFromExternalLibrary(sourceFile);
+  if (isExternal) return false;
+  const isSpec = isSpecFile(sourceFile.fileName);
+  if (isSpec) return false;
+  return typeScriptFilePattern.test(sourceFile.fileName);
+};
+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);
+  }
+  const maps = { all, current };
+  return maps;
+};
+var dropEntries = (index, stale) => {
+  for (const [fileName, entry] of index.entries) {
+    const isStale = stale(entry);
+    if (isStale) {
+      index.entries.delete(fileName);
+    }
+  }
+};
+var isReplaced = (sourceFile, dependencies, maps) => {
+  const indexedSourceFile = maps.current.get(sourceFile.fileName);
+  if (indexedSourceFile !== sourceFile) return true;
+  for (const dependency of dependencies) {
+    const indexedDependency = maps.all.get(dependency.fileName);
+    if (indexedDependency !== dependency) return true;
+  }
+  return false;
+};
+var dropReplacedEntries = (index, maps) => {
+  const isEntryReplaced = (entry) => {
+    return isReplaced(entry.sourceFile, entry.dependencies, maps);
+  };
+  dropEntries(index, isEntryReplaced);
+};
+var dropEntriesMentioning = (index, names) => {
+  if (names.size === 0) return;
+  if (index.entries.size === 0) return;
+  const nameList = [...names];
+  const mentionsName = (entry) => {
+    return nameList.some((name) => entry.sourceFile.text.includes(name));
+  };
+  dropEntries(index, mentionsName);
+};
+var templateVersionChecker = () => {
+  const checked = /* @__PURE__ */ new Map();
+  return (version) => {
+    const key2 = `${version.fileName}\0${version.mtimeNs}\0${version.size}`;
+    const known = checked.get(key2);
+    if (known !== void 0) return known;
+    const current = templateFileIsCurrent(version);
+    checked.set(key2, current);
+    return current;
+  };
+};
+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) => {
+    return !entry.templateVersions.every(isCurrent);
+  };
+  dropEntries(index, hasStaleTemplate);
+  index.templateCheckedAt = now;
+  index.templateCheckDuration = performance.now() - now;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-candidate-names.ts
+var import_typescript16 = require("typescript");
+var isDecoratedClass = (node) => {
+  const isDecoratable = (0, import_typescript16.canHaveDecorators)(node);
+  if (!isDecoratable) return false;
+  const decorators = (0, import_typescript16.getDecorators)(node);
+  const decoratorCount = decorators?.length ?? 0;
+  return decoratorCount > 0;
+};
+var addMemberNames = (node, names) => {
+  const isClass = (0, import_typescript16.isClassLike)(node);
+  if (!isClass) return;
+  const isDecorated = isDecoratedClass(node);
+  if (!isDecorated) return;
+  for (const member of node.members) {
+    if (!member.name) continue;
+    const isIdentifierName = (0, import_typescript16.isIdentifier)(member.name);
+    const isStringName = (0, import_typescript16.isStringLiteralLike)(member.name);
+    const isNamedMember = isIdentifierName || isStringName;
+    if (isNamedMember) {
+      names.add(member.name.text);
+    }
+  }
+};
+var collectCandidateNames = (sourceFile) => {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    addMemberNames(node, names);
+    (0, import_typescript16.forEachChild)(node, visit);
+  };
+  visit(sourceFile);
+  return names;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-classes.ts
+var dropReplacedClasses = (index, maps) => {
+  let changed = false;
+  for (const [fileName, fileClasses] of index.classes) {
+    const replaced = isReplaced(
+      fileClasses.sourceFile,
+      fileClasses.dependencies,
+      maps
+    );
+    if (!replaced) continue;
+    index.classes.delete(fileName);
+    changed = true;
+  }
+  return changed;
+};
+var addCandidateNames = (index, candidateNames, newNames) => {
+  for (const name of candidateNames) {
+    const isKnownName = index.candidateNames.has(name);
+    if (isKnownName) continue;
+    index.candidateNames.add(name);
+    newNames.add(name);
+  }
+};
+var indexFileClasses = (index, sourceFile, checker, newNames) => {
+  const candidateNames = collectCandidateNames(sourceFile);
+  addCandidateNames(index, candidateNames, newNames);
+  const { classes, dependencies } = angularClasses(sourceFile, checker());
+  const fileClasses = {
+    candidateNames,
+    classes,
+    dependencies,
+    sourceFile
+  };
+  index.classes.set(sourceFile.fileName, fileClasses);
+  index.entries.delete(sourceFile.fileName);
+};
+var indexNewClasses = (index, current, checker, newNames) => {
+  let changed = false;
+  for (const [fileName, sourceFile] of current) {
+    const isIndexed = index.classes.has(fileName);
+    if (isIndexed) continue;
+    indexFileClasses(index, sourceFile, checker, newNames);
+    changed = true;
+  }
+  return changed;
+};
+var rebuildDirectives = (index) => {
+  const fileClasses = [...index.classes.values()];
+  const classes = fileClasses.flatMap((entry) => entry.classes);
+  const shape = directiveShape(classes);
+  index.directives = buildDirectiveIndex(classes);
+  if (shape === index.directiveShape) return;
+  index.directiveShape = shape;
+  dropEntries(index, (entry) => entry.usedDirectiveIndex);
+};
+var reconcileClasses = (index, maps, 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) {
+    rebuildDirectives(index);
+  }
+  return newNames;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-index-reconciliation.ts
+var lazyChecker = (program) => {
+  let typeChecker;
+  return () => typeChecker ??= program.getTypeChecker();
+};
+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);
+  }
+};
+var reindexProgram = (index, program, checker) => {
+  const maps = sourceFileMaps(program);
+  dropReplacedEntries(index, maps);
+  const newNames = reconcileClasses(index, maps, checker);
+  dropEntriesMentioning(index, newNames);
+  index.program = program;
+  index.usage = void 0;
+  dropStaleTemplateEntries(index, true);
+  indexMissingEntries(index, maps.current.values(), 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) => {
+  const checker = lazyChecker(program);
+  const isNewProgram = index.program !== program;
+  if (isNewProgram) {
+    reindexProgram(index, program, checker);
+    return;
+  }
+  refreshTemplateEntries(index, program, checker);
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
+var indexes = /* @__PURE__ */ new Map();
+var memberName = (node) => {
+  const isMember = (0, import_typescript17.isClassElement)(node);
+  if (!isMember) return null;
+  if (!node.name) return null;
+  const isIdentifierName = (0, import_typescript17.isIdentifier)(node.name);
+  const isStringName = (0, import_typescript17.isStringLiteralLike)(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);
+    }
+  };
+  return index.usage;
+};
+var createIndex = () => {
+  const emptyIndex = {
+    candidateNames: /* @__PURE__ */ new Set(),
+    classes: /* @__PURE__ */ new Map(),
+    directives: buildDirectiveIndex([]),
+    directiveShape: "",
+    entries: /* @__PURE__ */ new Map(),
+    program: null,
+    templateCheckDuration: 0,
+    templateCheckedAt: 0,
+    usage: void 0
+  };
+  return emptyIndex;
+};
+var projectUsageIsCurrent = (program) => {
+  const configFilePath = program.getCompilerOptions()["configFilePath"];
+  return typeof configFilePath === "string" && indexes.get(configFilePath)?.program === program;
+};
+var projectUsage = (program) => {
+  const configFilePath = program.getCompilerOptions()["configFilePath"];
+  if (typeof configFilePath !== "string") return null;
+  let index = indexes.get(configFilePath);
+  if (!index) {
+    index = createIndex();
+    indexes.set(configFilePath, index);
+  }
+  try {
+    reconcile(index, program);
+    return usageOf(index);
+  } catch {
+    indexes.delete(configFilePath);
+    return null;
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
+var docs = {
+  description: "Disallow unread instance fields and methods in Angular components and directives"
+};
+var messages = {
+  unusedField: "Angular instance field '{{name}}' is never read.",
+  unusedMethod: "Angular instance method '{{name}}' is never read."
+};
+var allowEffectFieldsSchema = {
+  type: "boolean",
+  description: "Allow Angular effect() fields with automatic cleanup."
+};
+var analysisSchema = {
+  type: "string",
+  enum: ["local", "project"],
+  description: "Choose local-file or typed whole-project analysis."
+};
+var properties = {
+  allowEffectFields: allowEffectFieldsSchema,
+  analysis: analysisSchema
+};
+var optionsSchema = {
+  type: "object",
+  properties,
+  additionalProperties: false
+};
+var schema = [optionsSchema];
+var meta = {
+  type: "problem",
+  docs,
+  schema,
+  messages
+};
+var ruleDefaults = {
+  allowEffectFields: false,
+  analysis: "local"
+};
+var defaultOptions = [ruleDefaults];
+var createRule = import_utils10.ESLintUtils.RuleCreator(
+  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
+);
+var projectParserServices = (context, analysis) => {
+  if (analysis !== "project") return void 0;
+  try {
+    return import_utils10.ESLintUtils.getParserServices(context);
+  } catch {
+    throw new Error(
+      "Project analysis requires parser services with type information."
+    );
+  }
+};
+var projectMemberUsedFor = (parserServices) => {
+  if (parserServices === void 0) return void 0;
+  let usage;
+  const memberUsed = (node) => {
+    if (usage === void 0) {
+      usage = projectUsage(parserServices.program);
+    }
+    return usage?.has(parserServices.esTreeNodeToTSNodeMap.get(node)) ?? true;
+  };
+  return memberUsed;
+};
+var no_unused_angular_instance_fields_default = createRule({
+  name: "no-unused-instance-fields",
+  meta,
+  defaultOptions,
+  create(context, [options]) {
+    const analysis = options.analysis ?? "local";
+    const isSpec = isSpecFile(context.filename);
+    const noListeners = {};
+    if (analysis === "project" && isSpec) return noListeners;
+    const parserServices = projectParserServices(context, analysis);
+    const imports = angularClassImports(context.sourceCode.ast);
+    if (!imports) return noListeners;
+    const classes = [];
+    const stack = [];
+    const dynamicClasses = /* @__PURE__ */ new Set();
+    const projectIndexed = () => {
+      if (parserServices === void 0) return false;
+      return projectUsageIsCurrent(parserServices.program);
+    };
+    const reportOptions = {
+      allowEffectFields: options.allowEffectFields ?? false,
+      classes,
+      context,
+      dynamicClasses,
+      imports,
+      projectIndexed,
+      projectMemberUsed: projectMemberUsedFor(parserServices)
+    };
+    const readListeners = classReadVisitor(classes, stack, dynamicClasses);
+    const listeners = {
+      ...readListeners,
+      "Program:exit"() {
+        reportUnusedMembers(reportOptions);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/angular.ts
+var lintSuiteAngularPlugin = definePlugin("lint-suite-angular", {
+  "no-unused-instance-fields": no_unused_angular_instance_fields_default
+});
+var angular = (0, import_config2.defineConfig)([
+  {
+    files: ["**/*.ts"],
+    extends: [...import_angular_eslint2.configs.tsRecommended],
+    plugins: {
+      "lint-suite-angular": lintSuiteAngularPlugin
+    },
+    languageOptions: {
+      globals: {
+        ...import_globals.default.browser,
+        ...import_globals.default.es2025,
+        ...import_globals.default.node
+      },
+      parserOptions: {
+        projectService: true
+      }
+    },
+    processor: import_angular_eslint2.processInlineTemplates,
+    rules: {
+      "lint-suite-angular/no-unused-instance-fields": [
+        "error",
+        { analysis: "project" }
+      ],
+      "@angular-eslint/prefer-on-push-component-change-detection": "error",
+      // v22: flags only explicit opt-out of OnPush (omission now means OnPush)
+      "@angular-eslint/prefer-signals": "error",
+      "@angular-eslint/use-injectable-provided-in": "error",
+      "@angular-eslint/prefer-signal-model": "error",
+      "@angular-eslint/no-uncalled-signals": "error",
+      "@angular-eslint/prefer-host-metadata-property": "error",
+      "@angular-eslint/no-implicit-take-until-destroyed": "error",
+      // v21.2.0: Enforce explicit DestroyRef
+      "@angular-eslint/no-async-lifecycle-method": "error",
+      // Prevent async lifecycle hooks
+      "@angular-eslint/prefer-output-readonly": "warn",
+      // Prevent accidental reassignment
+      "@angular-eslint/prefer-output-emitter-ref": "warn",
+      // Modern output() function over @Output()
+      "@angular-eslint/sort-lifecycle-methods": "warn",
+      // Consistent lifecycle method ordering
+      "@angular-eslint/computed-must-return": "error",
+      // Catch silent computed() bugs missing a return
+      "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
+      // Catch duplicate imports/providers in @Component/@NgModule
+      "@angular-eslint/no-lifecycle-call": "error",
+      // Forbid manual this.ngOnInit() calls
+      "@angular-eslint/require-lifecycle-on-prototype": "error",
+      // Lifecycle hooks must be methods, not arrow-fn fields
+      "@angular-eslint/relative-url-prefix": "error",
+      // Require ./ in templateUrl/styleUrl for portability
+      "@angular-eslint/use-component-selector": "error",
+      // All components must declare a selector
+      "@angular-eslint/no-developer-preview": "warn",
+      // Flag APIs marked @developerPreview (no breaking-change policy)
+      "@angular-eslint/no-experimental": "warn"
+      // Flag APIs marked @experimental
+    }
+  }
+]);
+
+// packages/lint-suite/src/lib/base.ts
+var import_config6 = require("eslint/config");
+
+// packages/lint-suite/src/lib/base-limits.ts
+var import_config3 = require("eslint/config");
+var baseLimits = (0, import_config3.defineConfig)([
+  {
+    files: [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.cjs",
+      "**/*.mjs",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.cts",
+      "**/*.mts",
+      "**/*.html"
+    ],
+    rules: {
+      "max-lines": [
+        "error",
+        {
+          max: 150,
+          skipBlankLines: true,
+          skipComments: true
+        }
+      ]
+    }
+  },
+  {
+    files: [
+      "**/*.spec.ts",
+      "**/*.test.ts",
+      "**/*.spec.js",
+      "**/*.test.js",
+      "**/*.e2e.ts",
+      "**/*.e2e.js"
+    ],
+    rules: {
+      "max-lines-per-function": "off",
+      complexity: ["warn", { max: 3 }],
+      "max-lines": [
+        "error",
+        {
+          max: 300,
+          skipBlankLines: true,
+          skipComments: true
+        }
+      ]
+    }
+  },
+  {
+    files: ["**/*.action.ts"],
+    rules: {
+      "max-classes-per-file": "off"
+    }
+  },
+  {
+    files: ["**/*.state.ts"],
+    rules: {
+      "class-methods-use-this": "off"
+    }
+  }
+]);
+
+// packages/lint-suite/src/lib/base-practices.ts
+var import_config4 = require("eslint/config");
+var basePractices = (0, import_config4.defineConfig)([
+  {
+    files: [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.cjs",
+      "**/*.mjs",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.cts",
+      "**/*.mts"
+    ],
+    rules: {
+      "no-param-reassign": "error",
+      "no-alert": "error",
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+      "no-debugger": "error",
+      eqeqeq: ["error", "always", { null: "ignore" }],
+      curly: ["error", "multi-line"],
+      "prefer-const": ["error", { destructuring: "all" }],
+      "no-var": "error",
+      "object-shorthand": "error",
+      "prefer-arrow-callback": "error",
+      "no-useless-concat": "error",
+      "prefer-template": "error",
+      "no-nested-ternary": "error",
+      "no-useless-assignment": "error",
+      // NEW: Catch unused assignments (ESLint v9)
+      "no-object-constructor": "error",
+      // Disallow new Object() without arguments
+      "no-else-return": ["error", { allowElseIf: false }],
+      // Prefer early returns
+      "no-multi-assign": "error",
+      // Disallow chaining assignments
+      radix: "error",
+      // Require radix parameter for parseInt()
+      yoda: "error",
+      // Disallow yoda conditions (`if ("red" === color)`)
+      complexity: ["warn", 10],
+      // Warn if function complexity is high
+      "max-depth": ["warn", 4],
+      // Warn on deeply nested blocks
+      "max-lines-per-function": [
+        "warn",
+        { max: 50, skipBlankLines: true, skipComments: true }
+      ],
+      // Warn on long functions
+      "max-params": ["warn", 4],
       // Warn on functions with many parameters
       "no-lonely-if": "error",
       // Disallow if statements as the only statement in an else block
@@ -915,7 +2896,16 @@ var base = (0, import_config3.defineConfig)([
         }
       ]
     }
-  },
+  }
+]);
+
+// packages/lint-suite/src/lib/base-recommended.ts
+var import_eslint_plugin = require("@nx/eslint-plugin");
+var import_eslint_plugin2 = __toESM(require("@stylistic/eslint-plugin"), 1);
+var import_config5 = require("eslint/config");
+var import_eslint_plugin_import_x = __toESM(require("eslint-plugin-import-x"), 1);
+var baseRecommended = (0, import_config5.defineConfig)([
+  { extends: [...import_eslint_plugin.configs["flat/base"]] },
   {
     files: [
       "**/*.js",
@@ -925,68 +2915,161 @@ var base = (0, import_config3.defineConfig)([
       "**/*.ts",
       "**/*.tsx",
       "**/*.cts",
-      "**/*.mts",
-      "**/*.html"
+      "**/*.mts"
     ],
-    rules: {
-      "max-lines": [
-        "error",
-        {
-          max: 150,
-          skipBlankLines: true,
-          skipComments: true
-        }
-      ]
-    }
+    extends: [import_eslint_plugin_import_x.default.flatConfigs.recommended]
   },
   {
     files: [
-      "**/*.spec.ts",
-      "**/*.test.ts",
-      "**/*.spec.js",
-      "**/*.test.js",
-      "**/*.e2e.ts",
-      "**/*.e2e.js"
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.cjs",
+      "**/*.mjs",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.cts",
+      "**/*.mts"
+    ],
+    extends: [import_eslint_plugin2.default.configs.recommended]
+  }
+]);
+
+// packages/lint-suite/src/lib/base.ts
+var base = (0, import_config6.defineConfig)([
+  ...baseRecommended,
+  ...basePractices,
+  ...baseLimits
+]);
+
+// packages/lint-suite/src/lib/boundaries.ts
+var import_config7 = require("eslint/config");
+var import_eslint_plugin_boundaries = __toESM(require("eslint-plugin-boundaries"), 1);
+var boundaries = (0, import_config7.defineConfig)([
+  {
+    files: [
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.cts",
+      "**/*.mts"
     ],
+    plugins: {
+      boundaries: import_eslint_plugin_boundaries.default
+    },
+    settings: {
+      "boundaries/elements": [
+        {
+          type: "feature",
+          pattern: "**/feature/**"
+        },
+        {
+          type: "data-access",
+          pattern: "**/data-access/**"
+        },
+        {
+          type: "domain-logic",
+          pattern: "**/domain-logic/**"
+        },
+        {
+          type: "ui",
+          pattern: "**/ui/**"
+        },
+        {
+          type: "common",
+          pattern: "**/common/**"
+        },
+        {
+          type: "utils",
+          pattern: "**/utils/**"
+        }
+      ],
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true
+        }
+      }
+    },
     rules: {
-      "max-lines-per-function": "off",
-      complexity: ["warn", { max: 3 }],
-      "max-lines": [
+      ...import_eslint_plugin_boundaries.default.configs.recommended.rules,
+      "boundaries/dependencies": [
         "error",
         {
-          max: 300,
-          skipBlankLines: true,
-          skipComments: true
+          default: "disallow",
+          message: "{{to.element.types}} is not allowed to be imported in {{from.element.types}}",
+          policies: [
+            {
+              from: { element: { type: "feature" } },
+              allow: [
+                { to: { element: { type: "feature" } } },
+                { to: { element: { type: "ui" } } },
+                { to: { element: { type: "domain-logic" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
+              ]
+            },
+            {
+              from: { element: { type: "domain-logic" } },
+              allow: [
+                { to: { element: { type: "domain-logic" } } },
+                { to: { element: { type: "data-access" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
+              ]
+            },
+            {
+              from: { element: { type: "data-access" } },
+              allow: [
+                { to: { element: { type: "data-access" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
+              ]
+            },
+            {
+              from: { element: { type: "ui" } },
+              allow: [
+                { to: { element: { type: "ui" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
+              ]
+            },
+            {
+              from: { element: { type: "utils" } },
+              allow: [
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
+              ]
+            },
+            {
+              from: { element: { type: "common" } },
+              allow: [{ to: { element: { type: "common" } } }]
+            }
+          ]
         }
       ]
     }
   },
   {
-    files: ["**/*.action.ts"],
-    rules: {
-      "max-classes-per-file": "off"
-    }
-  },
-  {
-    files: ["**/*.state.ts"],
+    files: ["**/*.stories.ts"],
     rules: {
-      "class-methods-use-this": "off"
+      "boundaries/dependencies": "off"
     }
   }
 ]);
 
 // packages/lint-suite/src/lib/javascript.ts
 var import_eslint_plugin3 = require("@nx/eslint-plugin");
-var import_config4 = require("eslint/config");
-var javascript = (0, import_config4.defineConfig)({
+var import_config8 = require("eslint/config");
+var nxJavascript = import_eslint_plugin3.configs["flat/javascript"];
+var javascript = (0, import_config8.defineConfig)({
   files: ["**/*.js", "**/*.jsx", "**/*.cjs", "**/*.mjs"],
-  extends: [...import_eslint_plugin3.configs["flat/javascript"]]
+  extends: nxJavascript
 });
 
 // packages/lint-suite/src/lib/json.ts
 var import_json = __toESM(require("@eslint/json"), 1);
-var import_config5 = require("eslint/config");
-var json = (0, import_config5.defineConfig)([
+var import_config9 = require("eslint/config");
+var json = (0, import_config9.defineConfig)([
   {
     plugins: { json: import_json.default }
   },
@@ -997,15 +3080,40 @@ var json = (0, import_config5.defineConfig)([
   }
 ]);
 
+// packages/lint-suite/src/lib/playwright.ts
+var import_config10 = require("eslint/config");
+var import_eslint_plugin_playwright = __toESM(require("eslint-plugin-playwright"), 1);
+var playwright = (0, import_config10.defineConfig)([
+  {
+    ...import_eslint_plugin_playwright.default.configs["flat/recommended"],
+    files: ["**/*.e2e.ts", "**/*.e2e.js"],
+    rules: {
+      ...import_eslint_plugin_playwright.default.configs["flat/recommended"].rules,
+      // Locator best practices
+      "playwright/prefer-locator": "error",
+      "playwright/prefer-native-locators": "error",
+      "playwright/no-nth-methods": "warn",
+      // Matcher improvements
+      "playwright/prefer-to-be": "error",
+      "playwright/prefer-to-have-count": "error",
+      "playwright/prefer-to-have-length": "error",
+      "playwright/prefer-comparison-matcher": "error",
+      // Test structure
+      "playwright/prefer-hooks-on-top": "error",
+      "playwright/require-top-level-describe": "warn"
+    }
+  }
+]);
+
 // packages/lint-suite/src/lib/prettier.ts
+var import_config11 = require("eslint/config");
 var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"), 1);
-var import_config6 = require("eslint/config");
-var prettier = (0, import_config6.defineConfig)([import_eslint_config_prettier.default]);
+var prettier = (0, import_config11.defineConfig)([import_eslint_config_prettier.default]);
 
 // packages/lint-suite/src/lib/rxjs.ts
 var import_eslint_plugin_rxjs = __toESM(require("@smarttools/eslint-plugin-rxjs"), 1);
-var import_config7 = require("eslint/config");
-var rxjs = (0, import_config7.defineConfig)([
+var import_config12 = require("eslint/config");
+var rxjs = (0, import_config12.defineConfig)([
   {
     files: [
       "**/*.js",
@@ -1080,9 +3188,9 @@ var rxjs = (0, import_config7.defineConfig)([
 ]);
 
 // packages/lint-suite/src/lib/storybook.ts
+var import_config13 = require("eslint/config");
 var import_eslint_plugin_storybook = __toESM(require("eslint-plugin-storybook"), 1);
-var import_config8 = require("eslint/config");
-var storybook = (0, import_config8.defineConfig)([
+var storybook = (0, import_config13.defineConfig)([
   {
     ignores: ["!.storybook"],
     files: ["**/*.stories.ts"],
@@ -1097,263 +3205,14 @@ var storybook = (0, import_config8.defineConfig)([
 ]);
 
 // packages/lint-suite/src/lib/typescript.ts
-var import_eslint_plugin4 = require("@nx/eslint-plugin");
-var import_eslint_import_resolver_typescript = require("eslint-import-resolver-typescript");
-var import_eslint_plugin_import_x2 = __toESM(require("eslint-plugin-import-x"), 1);
-var import_config9 = require("eslint/config");
-
-// packages/lint-suite/src/lib/rules/explicit-accessibility.ts
-var import_utils5 = require("@typescript-eslint/utils");
-var createRule2 = import_utils5.ESLintUtils.RuleCreator(
-  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
-);
-var defaultOptions = {
-  defaultAccessibility: "private"
-};
-var getNodeName = (node) => {
-  if (!node) {
-    return "<unknown>";
-  }
-  if ("key" in node && node.key) {
-    if (node.key.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-      return node.key.name;
-    }
-    if (node.key.type === import_utils5.TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
-      return `#${node.key.name}`;
-    }
-    return "<computed/complex key>";
-  }
-  if ("kind" in node && node.kind === "constructor") {
-    return "constructor";
-  }
-  if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
-    const param = node.parameter;
-    if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-      return param.name;
-    }
-    if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
-      if (param.left.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-        return param.left.name;
-      }
-      return "<destructured parameter>";
-    }
-    return "<complex parameter>";
-  }
-  return "<unknown>";
-};
-var explicit_accessibility_default = createRule2({
-  name: "explicit-accessibility",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Require explicit accessibility modifiers on class members"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          defaultAccessibility: {
-            type: "string",
-            enum: ["public", "private", "protected"],
-            description: "The accessibility modifier to add if one is missing."
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected)."
-    }
-  },
-  defaultOptions: [defaultOptions],
-  create(context, [options]) {
-    const { defaultAccessibility } = { ...defaultOptions, ...options };
-    const sourceCode = context.sourceCode;
-    function checkNode(node) {
-      if (node.accessibility) {
-        return;
-      }
-      let reportNode = node;
-      const name = getNodeName(node);
-      if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.MethodDefinition || node.type === import_utils5.TSESTree.AST_NODE_TYPES.PropertyDefinition) {
-        reportNode = node.key;
-      } else {
-        const param = node.parameter;
-        if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-          reportNode = param;
-        } else if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.AssignmentPattern && param.left.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-          reportNode = param.left;
-        }
-      }
-      context.report({
-        node: reportNode ?? node,
-        messageId: "missingAccessibility",
-        data: { name },
-        fix(fixer) {
-          let insertText = `${defaultAccessibility} `;
-          let tokenToInsertBefore;
-          if (node.decorators.length > 0) {
-            const lastDecorator = node.decorators[node.decorators.length - 1];
-            tokenToInsertBefore = sourceCode.getTokenAfter(lastDecorator);
-          } else {
-            tokenToInsertBefore = sourceCode.getFirstToken(node);
-          }
-          if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty && node.readonly) {
-            const firstToken = sourceCode.getFirstToken(node);
-            if (firstToken?.value === "readonly") {
-              tokenToInsertBefore = firstToken;
-            }
-          }
-          if (!tokenToInsertBefore) return null;
-          const tokenAfterInsertion = sourceCode.getTokenAfter(
-            tokenToInsertBefore,
-            { includeComments: false }
-          );
-          const textBetween = sourceCode.text.slice(
-            tokenToInsertBefore.range[1],
-            tokenAfterInsertion?.range[0]
-          );
-          if (!/^\s/.test(textBetween)) {
-            insertText = ` ${insertText}`;
-          }
-          return fixer.insertTextBefore(tokenToInsertBefore, insertText);
-        }
-      });
-    }
-    return {
-      MethodDefinition(node) {
-        checkNode(node);
-      },
-      PropertyDefinition(node) {
-        checkNode(node);
-      },
-      TSParameterProperty(node) {
-        checkNode(node);
-      }
-    };
-  }
-});
+var import_config19 = require("eslint/config");
 
-// packages/lint-suite/src/lib/typescript.ts
-var localTypescriptRules = {
-  rules: {
-    "explicit-accessibility": explicit_accessibility_default
-  }
-};
-var typescript = (0, import_config9.defineConfig)([
-  // NOTE: Checks for 'prettier' and 'eslint-plugin-prettier'
-  {
-    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
-    extends: [
-      import_eslint_plugin_import_x2.default.flatConfigs.typescript,
-      ...import_eslint_plugin4.configs["flat/typescript"]
-    ]
-  },
+// packages/lint-suite/src/lib/typescript-consistency.ts
+var import_config14 = require("eslint/config");
+var typescriptConsistency = (0, import_config14.defineConfig)([
   {
     files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
-    plugins: { local: localTypescriptRules },
     rules: {
-      "local/explicit-accessibility": "error",
-      "@typescript-eslint/explicit-member-accessibility": "error",
-      "@typescript-eslint/explicit-function-return-type": "error",
-      "@typescript-eslint/no-empty-function": "error",
-      "@typescript-eslint/no-unused-vars": "error",
-      "@typescript-eslint/no-use-before-define": "error",
-      // A. Eliminating `any` (already covered by strict-type-checked, but explicit for clarity)
-      "@typescript-eslint/no-explicit-any": "error",
-      "@typescript-eslint/no-unsafe-assignment": "error",
-      "@typescript-eslint/no-unsafe-call": "error",
-      "@typescript-eslint/no-unsafe-member-access": "error",
-      "@typescript-eslint/no-unsafe-return": "error",
-      "@typescript-eslint/no-unsafe-argument": "error",
-      // New v8 type-safety rules (replacements for deprecated ban-types)
-      "@typescript-eslint/no-empty-object-type": "error",
-      // Bans confusing {} type
-      "@typescript-eslint/no-unsafe-function-type": "error",
-      // Bans Function type
-      "@typescript-eslint/no-wrapper-object-types": "error",
-      // Bans Number, String, Boolean wrappers
-      // B. Explicit Annotations (partially covered, explicit module boundaries is key)
-      "@typescript-eslint/explicit-module-boundary-types": "error",
-      // Consider enabling if maximum explicitness is desired, even if verbose:
-      // C. Null/Undefined Safety (Requires strictNullChecks)
-      "@typescript-eslint/no-non-null-assertion": "error",
-      "@typescript-eslint/prefer-nullish-coalescing": "error",
-      "@typescript-eslint/prefer-optional-chain": "error",
-      // D. Promise Handling (Supplementing plugin:promise/recommended)
-      "@typescript-eslint/no-floating-promises": [
-        "error",
-        { ignoreVoid: true }
-      ],
-      "@typescript-eslint/no-misused-promises": "warn",
-      // Already in recommended-type-checked
-      "@typescript-eslint/promise-function-async": "error",
-      "@typescript-eslint/await-thenable": "error",
-      // Already in recommended-type-checked
-      // E. Best Practices & Potential Errors (Some covered by presets, fine-tuning here)
-      "@typescript-eslint/no-inferrable-types": "warn",
-      // Keep as warn or disable if inference is preferred
-      "@typescript-eslint/no-require-imports": "error",
-      // Use ES modules (replaces deprecated no-var-requires)
-      "@typescript-eslint/only-throw-error": "error",
-      // Replaces deprecated no-throw-literal
-      "@typescript-eslint/no-array-delete": "error",
-      // Prevents delete arr[0]
-      "@typescript-eslint/return-await": ["error", "in-try-catch"],
-      // Better stack traces in try/catch
-      "@typescript-eslint/require-await": "error",
-      "@typescript-eslint/restrict-template-expressions": [
-        "error",
-        { allowNumber: true, allowBoolean: true }
-      ],
-      // Allow numbers/booleans in templates
-      "@typescript-eslint/restrict-plus-operands": "error",
-      // Enforce consistent types for '+'
-      "@typescript-eslint/prefer-as-const": "error",
-      "@typescript-eslint/no-shadow": "error",
-      "@typescript-eslint/switch-exhaustiveness-check": "error",
-      // Ensure switch on unions is exhaustive
-      "@typescript-eslint/no-unused-expressions": [
-        "error",
-        { allowShortCircuit: true, allowTernary: true }
-      ],
-      "@typescript-eslint/no-useless-constructor": "error",
-      "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
-      // Prefer dot notation where possible
-      // Strict type-checked rules
-      "@typescript-eslint/no-unnecessary-condition": "error",
-      // Catches always-true/false conditions
-      "@typescript-eslint/no-confusing-void-expression": [
-        "error",
-        { ignoreArrowShorthand: true, ignoreVoidOperator: true }
-      ],
-      // Prevent confusing void usage
-      "@typescript-eslint/no-dynamic-delete": "error",
-      // Use Map instead of delete obj[key]
-      "@typescript-eslint/no-extraneous-class": [
-        "error",
-        { allowWithDecorator: true }
-      ],
-      // Allow Angular classes
-      "@typescript-eslint/no-invalid-void-type": "error",
-      // Restrict void to return types
-      "@typescript-eslint/unified-signatures": "error",
-      // Merge overloads where possible
-      "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
-      // Forbids foo! ?? bar
-      // Stylistic type-checked rules
-      "@typescript-eslint/prefer-find": "error",
-      // Use find() instead of filter()[0]
-      "@typescript-eslint/prefer-for-of": "error",
-      // Modern iteration
-      "@typescript-eslint/prefer-includes": "error",
-      // indexOf() → includes()
-      "@typescript-eslint/prefer-string-starts-ends-with": "error",
-      // Modern string methods
-      "@typescript-eslint/prefer-regexp-exec": "error",
-      // Better regex performance
-      // F. Consistency & Style (Some covered by stylistic-type-checked)
       "@typescript-eslint/consistent-type-assertions": [
         "error",
         { assertionStyle: "as", objectLiteralTypeAssertions: "never" }
@@ -1366,10 +3225,14 @@ var typescript = (0, import_config9.defineConfig)([
       "@typescript-eslint/naming-convention": [
         "error",
         {
-          selector: "objectLiteralProperty",
+          selector: ["objectLiteralProperty", "objectLiteralMethod"],
           modifiers: ["requiresQuotes"],
           format: null
         },
+        {
+          selector: "objectLiteralMethod",
+          format: ["camelCase", "PascalCase"]
+        },
         {
           selector: "objectLiteralProperty",
           format: ["camelCase", "snake_case", "PascalCase"]
@@ -1392,7 +3255,28 @@ var typescript = (0, import_config9.defineConfig)([
           selector: "property",
           format: ["camelCase", "PascalCase", "snake_case"]
         }
-      ],
+      ]
+    }
+  }
+]);
+
+// packages/lint-suite/src/lib/typescript-imports.ts
+var import_config15 = require("eslint/config");
+var import_eslint_import_resolver_typescript = require("eslint-import-resolver-typescript");
+var pathGroups = [
+  { pattern: "@angular/**", group: "builtin", position: "before" },
+  { pattern: "@nestjs/**", group: "builtin", position: "before" },
+  { pattern: "@shared/**", group: "internal", position: "before" },
+  { pattern: "@backend/**", group: "internal", position: "before" },
+  { pattern: "@frontend/**", group: "internal", position: "before" },
+  { pattern: "@*/shared/**", group: "internal", position: "before" },
+  { pattern: "@*/frontend/**", group: "internal", position: "after" },
+  { pattern: "@*/backend/**", group: "internal", position: "after" }
+];
+var typescriptImports = (0, import_config15.defineConfig)([
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
+    rules: {
       "import-x/order": [
         "error",
         {
@@ -1404,53 +3288,17 @@ var typescript = (0, import_config9.defineConfig)([
             "index",
             "unknown"
           ],
-          pathGroups: [
-            {
-              pattern: "@angular/**",
-              group: "builtin",
-              position: "before"
-            },
-            {
-              pattern: "@nestjs/**",
-              group: "builtin",
-              position: "before"
-            },
-            {
-              pattern: "@shared/**",
-              group: "internal",
-              position: "before"
-            },
-            {
-              pattern: "@backend/**",
-              group: "internal",
-              position: "before"
-            },
-            {
-              pattern: "@frontend/**",
-              group: "internal",
-              position: "before"
-            },
-            {
-              pattern: "@*/shared/**",
-              group: "internal",
-              position: "before"
-            },
-            {
-              pattern: "@*/frontend/**",
-              group: "internal",
-              position: "after"
-            },
-            {
-              pattern: "@*/backend/**",
-              group: "internal",
-              position: "after"
-            }
-          ],
+          pathGroups,
           pathGroupsExcludedImportTypes: ["builtin"],
           "newlines-between": "always",
           alphabetize: { order: "asc", caseInsensitive: true }
         }
       ],
+      // TypeScript already checks these four; import-x would re-parse every import with a parser resolved by name, which fails under pnpm.
+      "import-x/namespace": "off",
+      "import-x/default": "off",
+      "import-x/no-named-as-default": "off",
+      "import-x/no-named-as-default-member": "off",
       "import-x/no-unresolved": "error",
       "import-x/no-duplicates": "error",
       "import-x/prefer-default-export": "off",
@@ -1459,13 +3307,9 @@ var typescript = (0, import_config9.defineConfig)([
       "import-x/first": "error",
       "import-x/no-mutable-exports": "error",
       "import-x/no-self-import": "error",
-      // Prevents modules importing themselves
       "import-x/no-cycle": ["error", { maxDepth: 2, ignoreExternal: true }],
-      // Prevents circular dependencies
       "import-x/consistent-type-specifier-style": ["error", "prefer-top-level"],
-      // Consistent type imports
       "import-x/no-anonymous-default-export": "error"
-      // Improve code searchability
     },
     settings: {
       "import-x/resolver-next": [
@@ -1474,7 +3318,12 @@ var typescript = (0, import_config9.defineConfig)([
         })
       ]
     }
-  },
+  }
+]);
+
+// packages/lint-suite/src/lib/typescript-overrides.ts
+var import_config16 = require("eslint/config");
+var typescriptOverrides = (0, import_config16.defineConfig)([
   {
     files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
     languageOptions: {
@@ -1507,23 +3356,402 @@ var typescript = (0, import_config9.defineConfig)([
       "@typescript-eslint/unbound-method": "off",
       "@typescript-eslint/consistent-type-assertions": "off"
     }
-  },
+  },
+  {
+    files: ["**/*.stories.ts"],
+    rules: {
+      "@typescript-eslint/consistent-type-assertions": "off",
+      "@typescript-eslint/naming-convention": "off"
+    }
+  }
+]);
+
+// packages/lint-suite/src/lib/typescript-recommended.ts
+var import_eslint_plugin4 = require("@nx/eslint-plugin");
+var import_config17 = require("eslint/config");
+var import_eslint_plugin_import_x2 = __toESM(require("eslint-plugin-import-x"), 1);
+var nxTypescript = import_eslint_plugin4.configs["flat/typescript"];
+var typescriptRecommended = (0, import_config17.defineConfig)([
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
+    extends: [import_eslint_plugin_import_x2.default.flatConfigs.typescript, ...nxTypescript]
+  }
+]);
+
+// packages/lint-suite/src/lib/typescript-safety.ts
+var import_config18 = require("eslint/config");
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
+var import_utils11 = require("@typescript-eslint/utils");
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/common/explicit-accessibility.const.ts
+var accessibilities = [
+  "public",
+  "private",
+  "protected"
+];
+var docs2 = {
+  description: "Require explicit accessibility modifiers on class members"
+};
+var messages2 = {
+  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 properties2 = {
+  defaultAccessibility: defaultAccessibilitySchema
+};
+var optionsSchema2 = {
+  type: "object",
+  properties: properties2,
+  additionalProperties: false
+};
+var schema2 = [optionsSchema2];
+var meta2 = {
+  type: "suggestion",
+  docs: docs2,
+  fixable: "code",
+  hasSuggestions: true,
+  schema: schema2,
+  messages: messages2
+};
+var defaultOptions2 = [{ defaultAccessibility: "public" }];
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
+var createRule2 = import_utils11.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
+);
+var isPrivateMember = (node) => {
+  if (node.type === import_utils11.TSESTree.AST_NODE_TYPES.TSParameterProperty) return false;
+  return node.key.type === import_utils11.TSESTree.AST_NODE_TYPES.PrivateIdentifier;
+};
+var isConstructor = (node) => {
+  if (node.type !== import_utils11.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  return node.kind === "constructor";
+};
+var reportTarget = (node) => {
+  if (node.type !== import_utils11.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
+    return node.key;
+  }
+  const { parameter } = node;
+  if (parameter.type === import_utils11.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
+    return parameter.left;
+  }
+  return parameter;
+};
+var memberName2 = (target, sourceCode) => {
+  if (target.type === import_utils11.TSESTree.AST_NODE_TYPES.Identifier) return target.name;
+  return sourceCode.getText(target);
+};
+var modifierToken = (node, sourceCode) => {
+  const lastDecorator = node.decorators.at(-1);
+  if (!lastDecorator) return sourceCode.getFirstToken(node);
+  return sourceCode.getTokenAfter(lastDecorator);
+};
+var insertModifier = (node, accessibility, sourceCode) => {
+  const token = modifierToken(node, sourceCode);
+  if (!token) return () => null;
+  const lastDecorator = node.decorators.at(-1);
+  const adjacentToDecorator = lastDecorator?.range[1] === token.range[0];
+  const text2 = `${adjacentToDecorator ? " " : ""}${accessibility} `;
+  return (fixer) => fixer.insertTextBefore(token, text2);
+};
+var autoFixOf = (node, accessibility, sourceCode) => {
+  if (accessibility === "none") {
+    const noAutoFix = {};
+    return noAutoFix;
+  }
+  const fix = insertModifier(node, accessibility, sourceCode);
+  const autoFix = { fix };
+  return autoFix;
+};
+var suggestionOf = (node, accessibility, sourceCode) => {
+  const data = { accessibility };
+  const fix = insertModifier(node, accessibility, sourceCode);
+  const suggestion = {
+    messageId: "setAccessibility",
+    data,
+    fix
+  };
+  return suggestion;
+};
+var suggestionsOf = (node, fixAccessibility, sourceCode) => {
+  const isOtherAccessibility = (accessibility) => {
+    return accessibility !== fixAccessibility;
+  };
+  const suggestionFor = (accessibility) => {
+    return suggestionOf(node, accessibility, sourceCode);
+  };
+  return accessibilities.filter(isOtherAccessibility).map(suggestionFor);
+};
+var explicit_accessibility_default = createRule2({
+  name: "explicit-accessibility",
+  meta: meta2,
+  defaultOptions: defaultOptions2,
+  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
+var import_utils12 = require("@typescript-eslint/utils");
+var docs3 = {
+  description: "Require nested object types inside a type alias to be extracted to a named type alias"
+};
+var messages3 = {
+  inlineObjectType: "Inline object type must be extracted to a named type alias."
+};
+var meta3 = {
+  type: "suggestion",
+  docs: docs3,
+  schema: [],
+  messages: messages3
+};
+var createRule3 = import_utils12.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
+);
+var enclosingTypeAlias = (node) => {
+  let current = node.parent;
+  while (current && current.type !== import_utils12.TSESTree.AST_NODE_TYPES.Program) {
+    if (current.type === import_utils12.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return void 0;
+};
+var no_inline_object_types_default = createRule3({
+  name: "no-inline-object-types",
+  meta: meta3,
+  defaultOptions: [],
+  create(context) {
+    const listeners = {
+      TSTypeLiteral(node) {
+        const isAliasBody = node.parent.type === import_utils12.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration;
+        if (isAliasBody) return;
+        const enclosingAlias = enclosingTypeAlias(node);
+        if (!enclosingAlias) return;
+        const report = {
+          node,
+          messageId: "inlineObjectType"
+        };
+        context.report(report);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/rules/readonly-type-properties/readonly-type-properties.ts
+var import_utils13 = require("@typescript-eslint/utils");
+var docs4 = {
+  description: "Require readonly on primitive-typed type and interface properties"
+};
+var messages4 = {
+  missingReadonly: "Type property '{{ name }}' should be readonly. Disable this rule on the line if mutation is required."
+};
+var meta4 = {
+  type: "suggestion",
+  docs: docs4,
+  fixable: "code",
+  schema: [],
+  messages: messages4
+};
+var createRule4 = import_utils13.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#readonly-type-properties"
+);
+var propertyName3 = (node, sourceCode) => {
+  if (node.key.type === import_utils13.TSESTree.AST_NODE_TYPES.Identifier) {
+    return node.key.name;
+  }
+  return sourceCode.getText(node.key);
+};
+var PRIMITIVE_KEYWORDS = /* @__PURE__ */ new Set([
+  import_utils13.TSESTree.AST_NODE_TYPES.TSStringKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSSymbolKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSNullKeyword,
+  import_utils13.TSESTree.AST_NODE_TYPES.TSUndefinedKeyword
+]);
+var isPrimitive = (type) => {
+  const isPrimitiveKeyword = PRIMITIVE_KEYWORDS.has(type.type);
+  if (isPrimitiveKeyword) return true;
+  if (type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSLiteralType || type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSTemplateLiteralType) {
+    return true;
+  }
+  if (type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSUnionType || type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSIntersectionType) {
+    return type.types.every(isPrimitive);
+  }
+  return false;
+};
+var readonlyFix = (node, sourceCode) => {
+  return (fixer) => {
+    const firstToken = sourceCode.getFirstToken(node);
+    if (!firstToken) return null;
+    return fixer.insertTextBefore(firstToken, "readonly ");
+  };
+};
+var readonly_type_properties_default = createRule4({
+  name: "readonly-type-properties",
+  meta: meta4,
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    const listeners = {
+      TSPropertySignature(node) {
+        if (node.readonly || !node.typeAnnotation) return;
+        const isPrimitiveType = isPrimitive(node.typeAnnotation.typeAnnotation);
+        if (!isPrimitiveType) return;
+        const name = propertyName3(node, sourceCode);
+        const data = { name };
+        const fix = readonlyFix(node, sourceCode);
+        const report = {
+          node: node.key,
+          messageId: "missingReadonly",
+          data,
+          fix
+        };
+        context.report(report);
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/typescript-local-plugin.ts
+var localPlugin = definePlugin("local", {
+  "explicit-accessibility": explicit_accessibility_default,
+  "readonly-type-properties": readonly_type_properties_default,
+  "no-inline-object-types": no_inline_object_types_default
+});
+
+// packages/lint-suite/src/lib/typescript-safety.ts
+var typescriptSafety = (0, import_config18.defineConfig)([
   {
-    files: ["**/*.stories.ts"],
+    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
+    plugins: { local: localPlugin },
     rules: {
-      "@typescript-eslint/consistent-type-assertions": "off",
-      "@typescript-eslint/naming-convention": "off"
+      "local/explicit-accessibility": "error",
+      "local/readonly-type-properties": "error",
+      "local/no-inline-object-types": "error",
+      "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/no-empty-function": "error",
+      "@typescript-eslint/no-unused-vars": "error",
+      "@typescript-eslint/no-use-before-define": "error",
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-empty-object-type": "error",
+      "@typescript-eslint/no-unsafe-function-type": "error",
+      "@typescript-eslint/no-wrapper-object-types": "error",
+      "@typescript-eslint/explicit-module-boundary-types": "error",
+      "@typescript-eslint/no-non-null-assertion": "error",
+      "@typescript-eslint/prefer-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-optional-chain": "error",
+      "@typescript-eslint/no-floating-promises": [
+        "error",
+        { ignoreVoid: true }
+      ],
+      "@typescript-eslint/no-misused-promises": "warn",
+      "@typescript-eslint/promise-function-async": "error",
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/no-inferrable-types": "warn",
+      "@typescript-eslint/no-require-imports": "error",
+      "@typescript-eslint/only-throw-error": "error",
+      "@typescript-eslint/no-array-delete": "error",
+      "@typescript-eslint/return-await": ["error", "in-try-catch"],
+      "@typescript-eslint/require-await": "error",
+      "@typescript-eslint/restrict-template-expressions": [
+        "error",
+        { allowNumber: true, allowBoolean: true }
+      ],
+      "@typescript-eslint/restrict-plus-operands": "error",
+      "@typescript-eslint/prefer-as-const": "error",
+      "@typescript-eslint/no-shadow": "error",
+      "@typescript-eslint/switch-exhaustiveness-check": "error",
+      "@typescript-eslint/no-unused-expressions": [
+        "error",
+        { allowShortCircuit: true, allowTernary: true }
+      ],
+      "@typescript-eslint/no-useless-constructor": "error",
+      "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+      "@typescript-eslint/no-unnecessary-condition": "error",
+      "@typescript-eslint/no-confusing-void-expression": [
+        "error",
+        { ignoreArrowShorthand: true, ignoreVoidOperator: true }
+      ],
+      "@typescript-eslint/no-dynamic-delete": "error",
+      "@typescript-eslint/no-extraneous-class": [
+        "error",
+        { allowWithDecorator: true }
+      ],
+      "@typescript-eslint/no-invalid-void-type": "error",
+      "@typescript-eslint/unified-signatures": "error",
+      "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-find": "error",
+      "@typescript-eslint/prefer-for-of": "error",
+      "@typescript-eslint/prefer-includes": "error",
+      "@typescript-eslint/prefer-string-starts-ends-with": "error",
+      "@typescript-eslint/prefer-regexp-exec": "error"
     }
   }
 ]);
 
+// packages/lint-suite/src/lib/typescript.ts
+var typescript = (0, import_config19.defineConfig)([
+  ...typescriptRecommended,
+  ...typescriptSafety,
+  ...typescriptConsistency,
+  ...typescriptImports,
+  ...typescriptOverrides
+]);
+
 // packages/lint-suite/src/lib/vitest.ts
 var import_eslint_plugin5 = __toESM(require("@vitest/eslint-plugin"), 1);
-var import_config10 = require("eslint/config");
+var import_config20 = require("eslint/config");
 var vitestPlugin = {
   vitest: import_eslint_plugin5.default
 };
-var vitest = (0, import_config10.defineConfig)([
+var vitest = (0, import_config20.defineConfig)([
   {
     files: ["**/*.spec.ts", "**/*.spec.js", "**/*.test.ts", "**/*.test.js"],
     plugins: vitestPlugin,
@@ -1546,147 +3774,6 @@ var vitest = (0, import_config10.defineConfig)([
   }
 ]);
 
-// packages/lint-suite/src/lib/playwright.ts
-var import_eslint_plugin_playwright = __toESM(require("eslint-plugin-playwright"), 1);
-var import_config11 = require("eslint/config");
-var playwright = (0, import_config11.defineConfig)([
-  {
-    ...import_eslint_plugin_playwright.default.configs["flat/recommended"],
-    files: ["**/*.e2e.ts", "**/*.e2e.js"],
-    rules: {
-      ...import_eslint_plugin_playwright.default.configs["flat/recommended"].rules,
-      // Locator best practices
-      "playwright/prefer-locator": "error",
-      "playwright/prefer-native-locators": "error",
-      "playwright/no-nth-methods": "warn",
-      // Matcher improvements
-      "playwright/prefer-to-be": "error",
-      "playwright/prefer-to-have-count": "error",
-      "playwright/prefer-to-have-length": "error",
-      "playwright/prefer-comparison-matcher": "error",
-      // Test structure
-      "playwright/prefer-hooks-on-top": "error",
-      "playwright/require-top-level-describe": "warn"
-    }
-  }
-]);
-
-// packages/lint-suite/src/lib/boundaries.ts
-var import_eslint_plugin_boundaries = __toESM(require("eslint-plugin-boundaries"), 1);
-var import_config12 = require("eslint/config");
-var boundaries = (0, import_config12.defineConfig)([
-  {
-    files: [
-      "**/*.js",
-      "**/*.jsx",
-      "**/*.ts",
-      "**/*.tsx",
-      "**/*.cts",
-      "**/*.mts"
-    ],
-    plugins: {
-      boundaries: import_eslint_plugin_boundaries.default
-    },
-    settings: {
-      "boundaries/elements": [
-        {
-          type: "feature",
-          pattern: "**/feature/**"
-        },
-        {
-          type: "data-access",
-          pattern: "**/data-access/**"
-        },
-        {
-          type: "domain-logic",
-          pattern: "**/domain-logic/**"
-        },
-        {
-          type: "ui",
-          pattern: "**/ui/**"
-        },
-        {
-          type: "common",
-          pattern: "**/common/**"
-        },
-        {
-          type: "utils",
-          pattern: "**/utils/**"
-        }
-      ],
-      "import/resolver": {
-        typescript: {
-          alwaysTryTypes: true
-        }
-      }
-    },
-    rules: {
-      ...import_eslint_plugin_boundaries.default.configs.recommended.rules,
-      "boundaries/dependencies": [
-        "error",
-        {
-          default: "disallow",
-          message: "{{to.element.types}} is not allowed to be imported in {{from.element.types}}",
-          policies: [
-            {
-              from: { element: { type: "feature" } },
-              allow: [
-                { to: { element: { type: "feature" } } },
-                { to: { element: { type: "ui" } } },
-                { to: { element: { type: "domain-logic" } } },
-                { to: { element: { type: "utils" } } },
-                { to: { element: { type: "common" } } }
-              ]
-            },
-            {
-              from: { element: { type: "domain-logic" } },
-              allow: [
-                { to: { element: { type: "domain-logic" } } },
-                { to: { element: { type: "data-access" } } },
-                { to: { element: { type: "utils" } } },
-                { to: { element: { type: "common" } } }
-              ]
-            },
-            {
-              from: { element: { type: "data-access" } },
-              allow: [
-                { to: { element: { type: "data-access" } } },
-                { to: { element: { type: "utils" } } },
-                { to: { element: { type: "common" } } }
-              ]
-            },
-            {
-              from: { element: { type: "ui" } },
-              allow: [
-                { to: { element: { type: "ui" } } },
-                { to: { element: { type: "utils" } } },
-                { to: { element: { type: "common" } } }
-              ]
-            },
-            {
-              from: { element: { type: "utils" } },
-              allow: [
-                { to: { element: { type: "utils" } } },
-                { to: { element: { type: "common" } } }
-              ]
-            },
-            {
-              from: { element: { type: "common" } },
-              allow: [{ to: { element: { type: "common" } } }]
-            }
-          ]
-        }
-      ]
-    }
-  },
-  {
-    files: ["**/*.stories.ts"],
-    rules: {
-      "boundaries/dependencies": "off"
-    }
-  }
-]);
-
 // packages/lint-suite/src/eslint.ts
 var recommended = [
   ...base,