@drskillissue/ganko 0.1.26 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { RuleOverrides, Logger, StringInterner } from '@drskillissue/ganko-shared';
-import { TSESLint, ParserServices, TSESTree } from '@typescript-eslint/utils';
 import ts from 'typescript';
+import { RuleOverrides, Logger, StringInterner } from '@drskillissue/ganko-shared';
 import { Declaration, AtRule, Root, Rule } from 'postcss';
 export { RULES, RULES_BY_CATEGORY, RuleEntry, getRule } from './rules-manifest.js';
 
@@ -41,6 +40,15 @@ interface Diagnostic {
     readonly fix?: Fix;
     readonly suggest?: readonly Suggestion[];
 }
+/** Comment entry extracted from TypeScript scanner */
+interface CommentEntry {
+    readonly pos: number;
+    readonly end: number;
+    readonly value: string;
+    readonly line: number;
+    readonly endLine: number;
+    readonly kind: ts.SyntaxKind.SingleLineCommentTrivia | ts.SyntaxKind.MultiLineCommentTrivia;
+}
 
 /** Emit callback type for pushing diagnostics */
 type Emit = (d: Diagnostic) => void;
@@ -56,7 +64,9 @@ interface Plugin<K extends string> {
     readonly kind: K;
     readonly extensions: readonly string[];
     /** Analyze files and emit diagnostics via callback */
-    analyze(files: readonly string[], emit: Emit): void;
+    analyze(files: readonly string[], emit: Emit, context?: {
+        program: ts.Program;
+    }): void;
 }
 
 /**
@@ -75,12 +85,15 @@ interface Plugin<K extends string> {
 interface RunnerConfig {
     readonly plugins: readonly Plugin<string>[];
     readonly rules?: RuleOverrides;
+    readonly program?: ts.Program;
 }
 /** Runner interface */
 interface Runner {
     run(files: readonly string[]): readonly Diagnostic[];
     /** Replace rule overrides. Takes effect on the next run() call. */
     setRuleOverrides(overrides: RuleOverrides): void;
+    /** Replace the TypeScript program. Takes effect on the next run() call. */
+    setProgram(program: ts.Program): void;
 }
 /**
  * Build an Emit wrapper that enforces rule overrides.
@@ -92,39 +105,13 @@ interface Runner {
 declare function createOverrideEmit(target: Emit, overrides: RuleOverrides): Emit;
 /**
  * Create a runner from configuration.
- *
- * @example
- * ```ts
- * const runner = createRunner({
- *   plugins: [SolidPlugin, CSSPlugin, CrossFilePlugin],
- *   rules: { "missing-jsdoc-comments": "off", "signal-call": "warn" },
- * })
- * const diagnostics = runner.run(projectFiles)
- * ```
  */
 declare function createRunner(config: RunnerConfig): Runner;
 
-/**
- * SolidInput - Input type for building SolidGraph from ESLint-parsed source.
- *
- * This defines the contract for what data is needed to build a Solid.js
- * program graph. It requires ESLint's SourceCode object which contains
- * the AST, scope manager, and parser services.
- */
-
-/**
- * Input for building a SolidGraph from ESLint-parsed source.
- */
 interface SolidInput {
-    /** Absolute path to the source file */
     readonly file: string;
-    /** ESLint SourceCode object containing AST and scope manager */
-    readonly sourceCode: TSESLint.SourceCode;
-    /** TypeScript parser services for type information (null if unavailable) */
-    readonly parserServices: Partial<ParserServices> | null;
-    /** TypeScript type checker for advanced type queries (null if unavailable) */
-    readonly checker: ts.TypeChecker | null;
-    /** Logger for debug output (omit for silent operation) */
+    readonly sourceFile: ts.SourceFile;
+    readonly checker: ts.TypeChecker;
     readonly logger?: Logger;
 }
 
@@ -168,19 +155,11 @@ interface ObjectPropertyInfo {
  * Service for resolving TypeScript types from ESLint parser services.
  */
 declare class TypeResolver {
-    private services;
-    private typeChecker;
+    private readonly checker;
     private typeCache;
     private solidSymbolCache;
     readonly logger: Logger;
-    constructor(logger?: Logger);
-    /**
-     * Configure the type resolver with ESLint parser services.
-     *
-     * Returns true if TypeScript services are available, false otherwise.
-     * When false, all type queries will return null/false gracefully.
-     */
-    initialize(parserServices: Partial<ParserServices> | undefined): boolean;
+    constructor(checker: ts.TypeChecker, logger?: Logger);
     private isSymbolFromSolid;
     private isSolidSymbol;
     /**
@@ -193,33 +172,33 @@ declare class TypeResolver {
      * Returns null if TypeScript services are not available or if the type
      * cannot be determined.
      */
-    getType(node: TSESTree.Node): TypeInfo | null;
+    getType(node: ts.Node): TypeInfo | null;
     /**
      * Check if a node's type is an Accessor type (Accessor<T>).
      */
-    isAccessorType(node: TSESTree.Node): boolean;
+    isAccessorType(node: ts.Node): boolean;
     /**
      * Check if a node's type is a Signal type (Signal<T>).
      */
-    isSignalType(node: TSESTree.Node): boolean;
+    isSignalType(node: ts.Node): boolean;
     /**
      * Check if a node's type is a Store type (Store<T>).
      */
-    isStoreType(node: TSESTree.Node): boolean;
+    isStoreType(node: ts.Node): boolean;
     /**
      * Check if a node's type is a Component type (Component<P>).
      */
-    isComponentType(node: TSESTree.Node): boolean;
+    isComponentType(node: ts.Node): boolean;
     /**
      * Determine the reactive kind of a variable based on its type.
      *
      * Returns null if the type is not reactive.
      */
-    getReactiveKind(node: TSESTree.Node): ReactiveKind | null;
+    getReactiveKind(node: ts.Node): ReactiveKind | null;
     /**
      * Get both reactive kind AND type info in a single call.
      */
-    getReactiveKindWithType(node: TSESTree.Node): {
+    getReactiveKindWithType(node: ts.Node): {
         kind: ReactiveKind | null;
         type: TypeInfo | null;
     };
@@ -230,18 +209,18 @@ declare class TypeResolver {
      * @param node The array expression node (e.g., props.users in `<For each={props.users}>`)
      * @returns "primitive" | "object" | "unknown"
      */
-    getArrayElementKind(node: TSESTree.Node): "primitive" | "object" | "unknown";
+    getArrayElementKind(node: ts.Node): "primitive" | "object" | "unknown";
     /**
      * Check if a node's type is an array type.
      * Detects Array<T>, T[], ReadonlyArray<T>, and tuple types.
      */
-    isArrayType(node: TSESTree.Node): boolean;
+    isArrayType(node: ts.Node): boolean;
     private checkIsArrayType;
     /**
      * Check if a node's type is callable (has call signatures).
      * Detects functions, arrow functions, and callable objects.
      */
-    isCallableType(node: TSESTree.Node): boolean;
+    isCallableType(node: ts.Node): boolean;
     /**
      * Check if a type assertion is unnecessary because the expression
      * is already assignable to the target type.
@@ -254,12 +233,12 @@ declare class TypeResolver {
      * @param targetType - The TypeNode being cast to
      * @returns true if the cast is unnecessary, false otherwise
      */
-    isUnnecessaryCast(expression: TSESTree.Expression, targetType: TSESTree.TypeNode): boolean;
+    isUnnecessaryCast(expression: ts.Expression, targetType: ts.TypeNode): boolean;
     /**
      * Get a human-readable string for a TypeScript type at a node.
      * Returns null if type info is unavailable.
      */
-    getTypeString(node: TSESTree.Node): string | null;
+    getTypeString(node: ts.Node): string | null;
     /**
      * Check if a property exists on an object's type.
      * Handles union types by checking the non-null/undefined constituents.
@@ -268,7 +247,7 @@ declare class TypeResolver {
      * @param propertyName The property name to look for
      * @returns true if property exists on type, false otherwise
      */
-    hasPropertyOnType(objectNode: TSESTree.Node, propertyName: string): boolean;
+    hasPropertyOnType(objectNode: ts.Node, propertyName: string): boolean;
     /**
      * Check if a property exists on a type, handling unions specially.
      */
@@ -282,7 +261,7 @@ declare class TypeResolver {
      * @param includeCallable Include function-typed properties (for JSX props)
      * @returns Array of property info or null if not expandable
      */
-    getObjectProperties(node: TSESTree.Node, maxProperties?: number, includeCallable?: boolean): readonly ObjectPropertyInfo[] | null;
+    getObjectProperties(node: ts.Node, maxProperties?: number, includeCallable?: boolean): readonly ObjectPropertyInfo[] | null;
     /**
      * Extract properties from a TypeScript type.
      * Returns null for types that can't be safely expanded.
@@ -303,7 +282,7 @@ declare class TypeResolver {
      * @param tagNode - The JSX identifier node (e.g. the `ConfirmActionDialog` in `<ConfirmActionDialog>`)
      * @returns Property info or null if not resolvable
      */
-    getComponentPropsProperties(tagNode: TSESTree.Node): readonly ObjectPropertyInfo[] | null;
+    getComponentPropsProperties(tagNode: ts.Node): readonly ObjectPropertyInfo[] | null;
     private analyzeType;
     /**
      * Get aggregated TypeFlags for a type.
@@ -347,7 +326,9 @@ interface VariableEntity$1 {
     name: string;
     file: FileEntity$1;
     scope: ScopeEntity;
-    declarations: TSESTree.Node[];
+    declarations: ts.Node[];
+    /** The initializer expression from the variable declaration (e.g. `expr` in `const x = expr`). */
+    initializer: ts.Expression | null;
     assignments: AssignmentEntity[];
     reads: ReadEntity[];
     type: TypeInfo | null;
@@ -364,15 +345,15 @@ interface VariableEntity$1 {
  */
 type ReactiveKind = "signal" | "store" | "props" | "memo" | "derived" | "accessor" | "resource";
 /** Assignment operator type extracted from AssignmentExpression */
-type AssignmentOperator = TSESTree.AssignmentExpression["operator"];
+type AssignmentOperator = ts.SyntaxKind;
 /**
  * Represents an assignment to a variable.
  */
 interface AssignmentEntity {
     id: number;
-    node: TSESTree.Node;
+    node: ts.Node;
     /** The assigned value expression */
-    value: TSESTree.Expression;
+    value: ts.Expression;
     /** The assignment operator ("=" for simple, "+=" etc for compound) */
     operator: AssignmentOperator | null;
     /** Whether this assignment is inside a loop */
@@ -385,7 +366,7 @@ interface AssignmentEntity {
  */
 interface ReadEntity {
     id: number;
-    node: TSESTree.Node;
+    node: ts.Node;
     scope: ScopeEntity;
     isProperAccess: boolean;
     /** Whether this read is inside a loop */
@@ -400,19 +381,14 @@ interface ReadEntity {
  * Represents a call expression in the program graph.
  */
 
-/**
- * Callee type for call expressions.
- * Includes T.Super for super() calls in class constructors.
- */
-type CalleeExpression = TSESTree.Expression | TSESTree.Super;
 /**
  * Represents a call expression in the SolidGraph.
  */
 interface CallEntity {
     id: number;
-    node: TSESTree.CallExpression | TSESTree.NewExpression;
+    node: ts.CallExpression | ts.NewExpression;
     file: FileEntity$1;
-    callee: CalleeExpression;
+    callee: ts.Expression;
     arguments: ArgumentEntity[];
     scope: ScopeEntity;
     resolvedTarget: FunctionEntity | null;
@@ -439,7 +415,7 @@ interface CallEntity {
  */
 interface ArgumentEntity {
     id: number;
-    node: TSESTree.Node;
+    node: ts.Node;
     index: number;
     /** Semantic for this argument position, or null if unknown */
     semantic: ArgumentSemantic | null;
@@ -520,7 +496,7 @@ type PrimitiveReturn = {
  */
 interface ReturnStatementEntity {
     id: number;
-    node: TSESTree.ReturnStatement;
+    node: ts.ReturnStatement;
     /** The containing function's ID */
     functionId: number;
     /** Whether this return has an argument (non-void return) */
@@ -535,7 +511,7 @@ interface ReturnStatementEntity {
  * Helper functions for working with function nodes.
  */
 
-type FunctionNode = TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+type FunctionNode = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration | ts.ConstructorDeclaration;
 
 /**
  * Function Entity
@@ -553,7 +529,7 @@ interface FunctionEntity {
     name: string | null;
     variableName: string | null;
     params: ParameterEntity[];
-    body: TSESTree.BlockStatement | TSESTree.Expression;
+    body: ts.Block | ts.Expression | undefined;
     async: boolean;
     generator: boolean;
     scope: ScopeEntity;
@@ -568,7 +544,7 @@ interface FunctionEntity {
     /** True if body contains at least one return with JSX */
     hasJSXReturn: boolean;
     /** The declaration node for JSDoc attachment (export wrapper, variable decl, or self) */
-    declarationNode: TSESTree.Node;
+    declarationNode: ts.Node;
     /** All return statements in this function */
     returnStatements: ReturnStatementEntity[];
     /** @internal Cached reactive captures for iteration */
@@ -578,14 +554,14 @@ interface FunctionEntity {
     /** @internal Reachability flags (bitmask) */
     _reachability: number;
     /** @internal Cached member accesses indexed by object identifier name */
-    _memberAccessesByIdentifier: Map<string, TSESTree.MemberExpression[]> | null;
+    _memberAccessesByIdentifier: Map<string, ts.PropertyAccessExpression[]> | null;
 }
 /**
  * Represents a function parameter.
  */
 interface ParameterEntity {
     id: number;
-    node: TSESTree.Parameter;
+    node: ts.ParameterDeclaration;
     name: string | null;
     index: number;
 }
@@ -612,7 +588,7 @@ type JSXAttributeKind = "prop" | "event-handler" | "ref" | "directive" | "spread
  */
 interface JSXElementEntity {
     id: number;
-    node: TSESTree.JSXElement | TSESTree.JSXFragment;
+    node: ts.JsxElement | ts.JsxSelfClosingElement | ts.JsxFragment;
     file: FileEntity$1;
     tag: string | null;
     tagName: string | null;
@@ -630,8 +606,8 @@ interface JSXElementEntity {
  */
 interface SpreadProp {
     name: string;
-    keyNode: TSESTree.Node;
-    valueNode: TSESTree.Node | null;
+    keyNode: ts.Node;
+    valueNode: ts.Node | null;
 }
 /**
  * Describes the complexity of a style object.
@@ -645,9 +621,9 @@ interface StyleComplexityInfo {
  */
 interface SpreadInfo {
     hasCallExpression: boolean;
-    callExpressionNode: TSESTree.CallExpression | null;
+    callExpressionNode: ts.CallExpression | null;
     hasMemberExpression: boolean;
-    memberExpressionNode: TSESTree.MemberExpression | null;
+    memberExpressionNode: ts.PropertyAccessExpression | ts.ElementAccessExpression | null;
     isConditionalSpread: boolean;
     conditionalSpreadType: "ternary" | "logical-and" | null;
 }
@@ -656,12 +632,12 @@ interface SpreadInfo {
  */
 interface JSXAttributeEntity {
     id: number;
-    node: TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
+    node: ts.JsxAttribute | ts.JsxSpreadAttribute;
     name: string | null;
     kind: JSXAttributeKind;
     namespace: string | null;
     spreadProps: SpreadProp[];
-    valueNode: TSESTree.Node | null;
+    valueNode: ts.Node | null;
     styleComplexity: StyleComplexityInfo | null;
     spreadInfo: SpreadInfo | null;
 }
@@ -670,7 +646,7 @@ interface JSXAttributeEntity {
  */
 interface JSXChildEntity {
     id: number;
-    node: TSESTree.Node;
+    node: ts.Node;
     kind: "element" | "expression" | "text";
 }
 /**
@@ -682,7 +658,7 @@ interface JSXContext {
     element: JSXElementEntity;
     attribute: JSXAttributeEntity | null;
     kind: "expression" | "attribute" | "child";
-    containerNode: TSESTree.JSXExpressionContainer | null;
+    containerNode: ts.JsxExpression | null;
 }
 
 /**
@@ -696,7 +672,7 @@ interface JSXContext {
  */
 interface ImportEntity {
     readonly id: number;
-    readonly node: TSESTree.ImportDeclaration;
+    readonly node: ts.ImportDeclaration;
     readonly file: FileEntity$1;
     readonly source: string;
     readonly specifiers: readonly ImportSpecifierEntity[];
@@ -712,7 +688,7 @@ interface ImportEntity {
  */
 interface ImportSpecifierEntity {
     readonly id: number;
-    readonly node: TSESTree.ImportSpecifier | TSESTree.ImportDefaultSpecifier | TSESTree.ImportNamespaceSpecifier;
+    readonly node: ts.ImportSpecifier | ts.ImportClause | ts.NamespaceImport;
     readonly localName: string;
     readonly importedName: string | null;
     readonly kind: "named" | "default" | "namespace";
@@ -784,13 +760,13 @@ interface FixableSpreadPattern {
  */
 interface ConditionalSpreadEntity {
     readonly id: number;
-    /** The spread node - SpreadElement for object spreads, JSXSpreadAttribute for JSX */
-    readonly node: TSESTree.SpreadElement | TSESTree.JSXSpreadAttribute;
+    /** The spread node - SpreadElement/SpreadAssignment for object spreads, JSXSpreadAttribute for JSX */
+    readonly node: ts.SpreadElement | ts.SpreadAssignment | ts.JsxSpreadAttribute;
     readonly spreadType: "ternary" | "logical-and";
     /** The parent object expression (null for JSX spreads) */
-    readonly parentObject: TSESTree.ObjectExpression | null;
+    readonly parentObject: ts.ObjectLiteralExpression | null;
     /** For JSX spreads, the opening element containing the spread attribute */
-    readonly parentJSXElement: TSESTree.JSXOpeningElement | null;
+    readonly parentJSXElement: ts.JsxOpeningElement | ts.JsxSelfClosingElement | null;
     readonly isInJSX: boolean;
     /**
      * Context where this spread appears.
@@ -819,16 +795,16 @@ type ObjectSpreadKind = "object-copy" | "object-merge" | "object-update" | "jsx-
  */
 interface ObjectSpreadEntity {
     readonly id: number;
-    /** The spread node - SpreadElement, JSXSpreadAttribute, or RestElement */
-    readonly node: TSESTree.SpreadElement | TSESTree.JSXSpreadAttribute | TSESTree.RestElement;
+    /** The spread node - SpreadElement, SpreadAssignment, JSXSpreadAttribute, or BindingElement */
+    readonly node: ts.SpreadElement | ts.SpreadAssignment | ts.JsxSpreadAttribute | ts.BindingElement;
     /** The kind of spread pattern */
     readonly kind: ObjectSpreadKind;
     /** The parent object expression (null for JSX spreads and rest patterns) */
-    readonly parentObject: TSESTree.ObjectExpression | null;
+    readonly parentObject: ts.ObjectLiteralExpression | null;
     /** For JSX spreads, the opening element containing the spread attribute */
-    readonly parentJSXElement: TSESTree.JSXOpeningElement | null;
+    readonly parentJSXElement: ts.JsxOpeningElement | ts.JsxSelfClosingElement | null;
     /** The parent pattern for rest destructuring (null otherwise) */
-    readonly parentPattern: TSESTree.ObjectPattern | null;
+    readonly parentPattern: ts.ObjectBindingPattern | null;
     /** True if inside a JSX element */
     readonly isInJSX: boolean;
     /** Number of spreads in the same object (for merge detection) */
@@ -882,7 +858,7 @@ interface ObjectSpreadEntity {
 interface FileEntity$1 {
     id: number;
     path: string;
-    sourceCode: TSESLint.SourceCode | null;
+    sourceFile: ts.SourceFile | null;
     functions: FunctionEntity[];
     calls: CallEntity[];
     variables: VariableEntity$1[];
@@ -907,7 +883,7 @@ interface FileEntity$1 {
 interface ScopeEntity {
     id: number;
     /** The AST node that creates this scope. May be null for fallback/synthetic scopes. */
-    node: TSESTree.Node | null;
+    node: ts.Node | null;
     file: FileEntity$1;
     kind: "program" | "function" | "block";
     parent: ScopeEntity | null;
@@ -1002,9 +978,9 @@ interface ExportEntity {
      */
     readonly signature: string;
     /** AST node for go-to-definition */
-    readonly node: TSESTree.Node;
+    readonly node: ts.Node;
     /** Location for quick access */
-    readonly loc: TSESTree.SourceLocation | null;
+    readonly loc: SourceLocation | null;
     /**
      * Source module for re-exports, null for local exports.
      * Set for `export { X } from "./mod"` and `export * from "./mod"`.
@@ -1028,14 +1004,14 @@ interface ExportEntity {
  */
 interface PropertyEntity {
     id: number;
-    node: TSESTree.PropertyDefinition;
+    node: ts.PropertyDeclaration;
     class: ClassEntity;
     name: string | null;
     accessibility: "public" | "private" | "protected" | undefined;
     static: boolean;
     readonly: boolean;
     /** The declaration node for JSDoc attachment (same as node for properties) */
-    declarationNode: TSESTree.Node;
+    declarationNode: ts.Node;
 }
 
 /**
@@ -1044,7 +1020,7 @@ interface PropertyEntity {
  * Represents a class in the program graph.
  */
 
-type ClassNode = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+type ClassNode = ts.ClassDeclaration | ts.ClassExpression;
 /**
  * Represents a class in the SolidGraph.
  */
@@ -1058,7 +1034,7 @@ interface ClassEntity {
     constructor: FunctionEntity | null;
     abstract: boolean;
     /** The declaration node for JSDoc attachment (export wrapper or self) */
-    declarationNode: TSESTree.Node;
+    declarationNode: ts.Node;
     /** @internal Variable entity if this class is assigned to a variable */
     _variable: VariableEntity$1 | null;
 }
@@ -1081,19 +1057,19 @@ interface ClassEntity {
 interface PropertyAssignmentEntity {
     readonly id: number;
     /** The AssignmentExpression node */
-    readonly node: TSESTree.AssignmentExpression;
+    readonly node: ts.BinaryExpression;
     /** The MemberExpression on the left side */
-    readonly target: TSESTree.MemberExpression;
+    readonly target: ts.PropertyAccessExpression | ts.ElementAccessExpression;
     /** The object being assigned to */
-    readonly object: TSESTree.Expression;
+    readonly object: ts.Expression;
     /** The property name (if computed, this may be an expression) */
-    readonly property: TSESTree.Expression | TSESTree.PrivateIdentifier;
+    readonly property: ts.Expression | ts.PrivateIdentifier;
     /** Whether property is computed (obj[prop] vs obj.prop) */
     readonly computed: boolean;
     /** The assigned value expression */
-    readonly value: TSESTree.Expression;
+    readonly value: ts.Expression;
     /** The assignment operator */
-    readonly operator: TSESTree.AssignmentExpression["operator"];
+    readonly operator: ts.SyntaxKind;
     /** Containing scope */
     readonly scope: ScopeEntity;
     /** Containing file */
@@ -1122,9 +1098,9 @@ interface PropertyAssignmentEntity {
 interface NonNullAssertionEntity {
     readonly id: number;
     /** The TSNonNullExpression node */
-    readonly node: TSESTree.TSNonNullExpression;
+    readonly node: ts.NonNullExpression;
     /** The expression being asserted as non-null */
-    readonly expression: TSESTree.Expression;
+    readonly expression: ts.Expression;
 }
 
 /**
@@ -1149,11 +1125,11 @@ type TypeAssertionKind = "simple" | "double" | "cast-to-any" | "cast-to-unknown"
 interface TypeAssertionEntity {
     readonly id: number;
     /** The assertion node (TSAsExpression or TSTypeAssertion) */
-    readonly node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+    readonly node: ts.AsExpression | ts.TypeAssertion;
     /** The expression being cast */
-    readonly expression: TSESTree.Expression;
+    readonly expression: ts.Expression;
     /** The type being cast to */
-    readonly typeAnnotation: TSESTree.TypeNode;
+    readonly typeAnnotation: ts.TypeNode;
     /** The kind of assertion */
     readonly kind: TypeAssertionKind;
     /** Whether this is inside a loop */
@@ -1182,11 +1158,11 @@ interface TypeAssertionEntity {
 interface TypePredicateEntity {
     readonly id: number;
     /** The function node */
-    readonly node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+    readonly node: FunctionNode;
     /** The parameter name being narrowed */
     readonly parameterName: string;
     /** The type being asserted */
-    readonly typeAnnotation: TSESTree.TypeNode;
+    readonly typeAnnotation: ts.TypeNode;
 }
 /**
  * Represents a generic function with type assertion in its return.
@@ -1201,11 +1177,11 @@ interface TypePredicateEntity {
 interface UnsafeGenericAssertionEntity {
     readonly id: number;
     /** The function node */
-    readonly node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+    readonly node: FunctionNode;
     /** The generic type parameter being asserted to */
     readonly typeParameterName: string;
     /** The type assertion node within the function */
-    readonly assertion: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+    readonly assertion: ts.AsExpression | ts.TypeAssertion;
 }
 /**
  * Where in the program an unsafe type annotation appears.
@@ -1233,8 +1209,8 @@ type UnsafeAnnotationKind = "any" | "unknown";
  */
 interface UnsafeTypeAnnotationEntity {
     readonly id: number;
-    /** The TSAnyKeyword or TSUnknownKeyword node */
-    readonly node: TSESTree.TSAnyKeyword | TSESTree.TSUnknownKeyword;
+    /** The AnyKeyword or UnknownKeyword type node */
+    readonly node: ts.TypeNode;
     /** Whether this is `any` or `unknown` */
     readonly kind: UnsafeAnnotationKind;
     /** Where the annotation appears */
@@ -1269,7 +1245,7 @@ interface UnsafeTypeAnnotationEntity {
 interface InlineImportEntity {
     readonly id: number;
     /** The TSImportType node */
-    readonly node: TSESTree.TSImportType;
+    readonly node: ts.ImportTypeNode;
     /** The file containing this inline import */
     readonly file: FileEntity$1;
     /** The module specifier being imported (e.g., "@typescript-eslint/utils") */
@@ -1379,7 +1355,7 @@ interface JSXStaticObjectKeyIndex {
     readonly keys: readonly string[];
 }
 interface JSXObjectPropertyWithElement {
-    readonly property: TSESTree.ObjectLiteralElementLike;
+    readonly property: ts.ObjectLiteralElementLike;
     readonly attr: JSXAttributeEntity;
     readonly element: JSXElementEntity;
 }
@@ -1394,7 +1370,8 @@ declare class SolidGraph {
     readonly kind: "solid";
     readonly file: string;
     readonly logger: Logger;
-    readonly sourceCode: TSESLint.SourceCode;
+    readonly sourceFile: ts.SourceFile;
+    readonly comments: readonly CommentEntry[];
     readonly typeResolver: TypeResolver;
     readonly fileEntity: FileEntity$1;
     private _nextScopeId;
@@ -1426,16 +1403,15 @@ declare class SolidGraph {
     readonly unsafeGenericAssertions: UnsafeGenericAssertionEntity[];
     readonly unsafeTypeAnnotations: UnsafeTypeAnnotationEntity[];
     readonly inlineImports: InlineImportEntity[];
-    readonly eslintScopeMap: Map<TSESLint.Scope.Scope, ScopeEntity>;
     readonly variablesByName: Map<string, VariableEntity$1[]>;
-    readonly functionsByNode: Map<TSESTree.Node, FunctionEntity>;
-    readonly functionsByDeclarationNode: Map<TSESTree.Node, FunctionEntity>;
+    readonly functionsByNode: Map<ts.Node, FunctionEntity>;
+    readonly functionsByDeclarationNode: Map<ts.Node, FunctionEntity>;
     readonly functionsByName: Map<string, FunctionEntity[]>;
-    readonly callsByNode: Map<TSESTree.CallExpression | TSESTree.NewExpression, CallEntity>;
+    readonly callsByNode: Map<ts.CallExpression | ts.NewExpression, CallEntity>;
     readonly callsByPrimitive: Map<string, CallEntity[]>;
     readonly callsByMethodName: Map<string, CallEntity[]>;
-    readonly callsByArgNode: Map<TSESTree.Node, ArgumentEntity>;
-    readonly jsxByNode: Map<TSESTree.JSXElement | TSESTree.JSXFragment, JSXElementEntity>;
+    readonly callsByArgNode: Map<ts.Node, ArgumentEntity>;
+    readonly jsxByNode: Map<ts.Node, JSXElementEntity>;
     readonly jsxByTag: Map<string, JSXElementEntity[]>;
     readonly jsxAttributesByElementId: Map<number, ReadonlyMap<string, JSXAttributeEntity>>;
     readonly jsxAttrsByKind: Map<JSXAttributeKind, JSXAttributeWithElement[]>;
@@ -1453,13 +1429,14 @@ declare class SolidGraph {
     readonly importsBySource: Map<string, ImportEntity[]>;
     readonly exportsByName: Map<string, ExportEntity>;
     readonly exportsByEntityId: Map<number, ExportEntity>;
-    readonly classesByNode: Map<TSESTree.ClassDeclaration | TSESTree.ClassExpression, ClassEntity>;
+    readonly classesByNode: Map<ts.ClassDeclaration | ts.ClassExpression, ClassEntity>;
     readonly classesByName: Map<string, ClassEntity[]>;
-    readonly unaryExpressionsByOperator: Map<string, TSESTree.UnaryExpression[]>;
-    readonly spreadElements: TSESTree.SpreadElement[];
-    readonly newExpressionsByCallee: Map<string, TSESTree.NewExpression[]>;
-    readonly identifiersByName: Map<string, TSESTree.Identifier[]>;
-    readonly positionIndex: PositionIndex;
+    readonly unaryExpressionsByOperator: Map<ts.SyntaxKind, ts.PrefixUnaryExpression[]>;
+    readonly spreadElements: (ts.SpreadElement | ts.SpreadAssignment)[];
+    readonly newExpressionsByCallee: Map<string, ts.NewExpression[]>;
+    readonly deleteExpressions: ts.DeleteExpression[];
+    readonly identifiersByName: Map<string, ts.Identifier[]>;
+    private _lineStartOffsets;
     firstScope: ScopeEntity | null;
     readonly componentScopes: Map<ScopeEntity, {
         scope: ScopeEntity;
@@ -1480,10 +1457,10 @@ declare class SolidGraph {
     dependencyEdges: DependencyEdge[];
     /** Ownership edges: parent owns child computation. */
     ownershipEdges: OwnershipEdge[];
-    readonly jsxContextCache: WeakMap<TSESTree.Node, JSXContext | null>;
-    readonly scopeForCache: WeakMap<TSESTree.Node, ScopeEntity>;
-    readonly onDepsCache: WeakMap<TSESTree.Node, boolean>;
-    readonly passthroughCache: WeakMap<TSESTree.Node, boolean>;
+    readonly jsxContextCache: WeakMap<ts.Node, JSXContext | null>;
+    readonly scopeForCache: WeakMap<ts.Node, ScopeEntity>;
+    readonly onDepsCache: WeakMap<ts.Node, boolean>;
+    readonly passthroughCache: WeakMap<ts.Node, boolean>;
     /**
      * Creates a new SolidGraph instance.
      *
@@ -1515,7 +1492,7 @@ declare class SolidGraph {
     /**
      * @internal Add a scope entity to the graph. Called by scopesPhase.
      */
-    addScope(scope: ScopeEntity, eslintScope: TSESLint.Scope.Scope): void;
+    addScope(scope: ScopeEntity): void;
     /**
      * @internal Add a variable entity to the graph. Called by scopesPhase.
      */
@@ -1581,24 +1558,26 @@ declare class SolidGraph {
      */
     buildReactiveIndex(): void;
     /** @internal */
-    addUnaryExpression(node: TSESTree.UnaryExpression): void;
+    addUnaryExpression(node: ts.PrefixUnaryExpression): void;
     /** @internal */
-    addSpreadElement(node: TSESTree.SpreadElement): void;
+    addDeleteExpression(node: ts.DeleteExpression): void;
     /** @internal */
-    addNewExpressionByCallee(name: string, node: TSESTree.NewExpression): void;
+    addSpreadElement(node: ts.SpreadElement | ts.SpreadAssignment): void;
     /** @internal */
-    addIdentifierReference(node: TSESTree.Identifier): void;
-    /** @internal Index node for O(1) position lookup. Children overwrite parents. */
-    addToPositionIndex(node: TSESTree.Node): void;
-}
-/**
- * O(1) position lookup index.
- * - nodeAtOffset[i] = smallest node containing character offset i
- * - lineStartOffsets[i] = character offset where line (i+1) starts
- */
-interface PositionIndex {
-    readonly nodeAtOffset: Array<TSESTree.Node | null>;
-    readonly lineStartOffsets: readonly number[];
+    addNewExpressionByCallee(name: string, node: ts.NewExpression): void;
+    /** @internal */
+    addIdentifierReference(node: ts.Identifier): void;
+    /**
+     * Line start offsets for position queries. Computed lazily — CLI lint
+     * never accesses this, so zero cost during analysis.
+     */
+    get lineStartOffsets(): readonly number[];
+    /**
+     * Find the deepest expression at a character offset using the AST.
+     * O(log n) via TypeScript's getTokenAtPosition + parent walk.
+     * Zero pre-computation — no dense array, no per-node writes during analysis.
+     */
+    findExpressionAtOffset(offset: number): ts.Node | null;
 }
 
 /**
@@ -3073,62 +3052,16 @@ declare function analyzeInput(input: SolidInput, emit: Emit): void;
  * cache graphs (e.g. CLI lint) can build once, run single-file rules,
  * and reuse the same graph for cross-file analysis.
  */
-declare function runSolidRules(graph: SolidGraph, sourceCode: TSESLint.SourceCode, emit: Emit): void;
+declare function runSolidRules(graph: SolidGraph, sourceFile: ts.SourceFile, emit: Emit): void;
 /**
  * The Solid.js plugin.
  *
- * Analyzes Solid.js files by reading from disk, parsing with
- * @typescript-eslint/parser, building a SolidGraph, and running all rules.
+ * Analyzes Solid.js files by building a SolidGraph and running all rules.
  * Rules push diagnostics via the emit callback.
- *
- * @example
- * ```ts
- * import { createRunner, SolidPlugin } from "@drskillissue/ganko"
- *
- * const runner = createRunner({ plugins: [SolidPlugin] })
- * const diagnostics = runner.run(["src/App.tsx"])
- * ```
  */
 declare const SolidPlugin: Plugin<"solid">;
 
-/**
- * Parse a file from disk into SolidInput.
- *
- * Reads the file, parses with @typescript-eslint/parser,
- * and wraps into a SourceCode object.
- *
- * @param path - Absolute file path
- * @param logger - Logger for debug output
- * @returns Parsed SolidInput
- */
-declare function parseFile(path: string, logger?: Logger): SolidInput;
-/**
- * Parse source content into SolidInput.
- *
- * Exposed for cases where content is already in memory
- * (e.g. LSP with unsaved changes, tests).
- *
- * @param path - Absolute file path
- * @param content - Source text
- * @param logger - Logger for debug output
- * @returns Parsed SolidInput
- */
-declare function parseContent(path: string, content: string, logger?: Logger): SolidInput;
-/**
- * Parse source content with an existing TypeScript Program for full type info.
- *
- * Uses parseAndGenerateServices with the `programs` option to build the
- * ESTree↔TSNode mapping against the caller's ts.Program. This gives the
- * SolidGraph access to getTypeAtLocation/getSymbolAtLocation for type-aware
- * rules and fixes (e.g. expanding JSX spreads into explicit props).
- *
- * @param path - Absolute file path (must be part of the program)
- * @param content - In-memory source content
- * @param program - TypeScript Program from the language service
- * @param logger - Logger for debug output
- * @returns Parsed SolidInput with full type info
- */
-declare function parseContentWithProgram(path: string, content: string, program: ts.Program, logger?: Logger): SolidInput;
+declare function createSolidInput(filePath: string, program: ts.Program, logger?: Logger): SolidInput;
 
 /**
  * Build a CSSGraph from input.
@@ -3220,4 +3153,4 @@ interface CrossRuleContext {
  */
 declare function runCrossFileRules(context: CrossRuleContext, emit: Emit, log?: Logger | undefined): void;
 
-export { CSSGraph, type CSSInput, CSSPlugin, type ComputationEntity, type DependencyEdge, type Diagnostic, type Fix, type FixOperation, GraphCache, type Plugin, type ReactiveKind, type ReadEntity, type Runner, SolidGraph, type SolidInput, SolidPlugin, type TailwindValidator, type VariableEntity$1 as VariableEntity, analyzeInput, buildCSSGraph, buildLayoutGraph, buildSolidGraph, createOverrideEmit, createRunner, parseContent, parseContentWithProgram, parseFile, resolveTailwindValidator, runCrossFileRules, runSolidRules, scanDependencyCustomProperties, setActivePolicy };
+export { CSSGraph, type CSSInput, CSSPlugin, type CommentEntry, type ComputationEntity, type DependencyEdge, type Diagnostic, type Fix, type FixOperation, GraphCache, type Plugin, type ReactiveKind, type ReadEntity, type Runner, SolidGraph, type SolidInput, SolidPlugin, type TailwindValidator, type VariableEntity$1 as VariableEntity, analyzeInput, buildCSSGraph, buildLayoutGraph, buildSolidGraph, createOverrideEmit, createRunner, createSolidInput, resolveTailwindValidator, runCrossFileRules, runSolidRules, scanDependencyCustomProperties, setActivePolicy };