@drskillissue/ganko 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3133 @@
+import { RuleOverrides, Logger, StringInterner } from '@drskillissue/ganko-shared';
+import { TSESLint, ParserServices, TSESTree } from '@typescript-eslint/utils';
+import ts from 'typescript';
+import { Declaration, AtRule, Root, Rule } from 'postcss';
+export { RULES, RULES_BY_CATEGORY, RuleEntry, getRule } from './rules-manifest.cjs';
+
+type MessageId = string;
+type Message = string;
+/**
+ * Diagnostic severity — matches RuleSeverityOverride minus "off".
+ * Rules that are "off" never emit, so diagnostics only carry "error" or "warn".
+ */
+type DiagnosticSeverity = "error" | "warn";
+interface SourceLocation {
+    readonly start: {
+        readonly line: number;
+        readonly column: number;
+    };
+    readonly end: {
+        readonly line: number;
+        readonly column: number;
+    };
+}
+interface FixOperation {
+    readonly range: readonly [number, number];
+    readonly text: string;
+}
+type Fix = readonly FixOperation[];
+interface Suggestion {
+    readonly messageId: MessageId;
+    readonly message: Message;
+    readonly fix: Fix;
+}
+interface Diagnostic {
+    readonly file: string;
+    readonly rule: string;
+    readonly messageId: MessageId;
+    readonly message: Message;
+    readonly severity: DiagnosticSeverity;
+    readonly loc: SourceLocation;
+    readonly fix?: Fix;
+    readonly suggest?: readonly Suggestion[];
+}
+
+/** Emit callback type for pushing diagnostics */
+type Emit = (d: Diagnostic) => void;
+/**
+ * A plugin provides a graph type and its rules.
+ *
+ * Plugins push data OUT via callbacks. The runner never stores typed graphs.
+ * Plugins run their own rules internally via the analyze() method.
+ *
+ * @typeParam K - The plugin kind string
+ */
+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;
+}
+
+/**
+ * Runner - Plugin-agnostic runner for ganko
+ *
+ * The runner takes a configuration with plugins and runs them against files.
+ * It never stores typed graphs - plugins handle their own graph building
+ * and rule execution internally via the analyze() method.
+ *
+ * Rule overrides allow callers (LSP, CLI) to disable rules or remap their
+ * severity without modifying rule definitions. The runner intercepts the
+ * Emit callback to enforce overrides before diagnostics reach the caller.
+ */
+
+/** Runner configuration */
+interface RunnerConfig {
+    readonly plugins: readonly Plugin<string>[];
+    readonly rules?: RuleOverrides;
+}
+/** Runner interface */
+interface Runner {
+    run(files: readonly string[]): readonly Diagnostic[];
+    /** Replace rule overrides. Takes effect on the next run() call. */
+    setRuleOverrides(overrides: RuleOverrides): void;
+}
+/**
+ * Build an Emit wrapper that enforces rule overrides.
+ *
+ * @param target - The underlying emit that collects diagnostics
+ * @param overrides - Current rule override map
+ * @returns Wrapped emit that suppresses/remaps per overrides
+ */
+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 logger?: Logger;
+}
+
+/**
+ * TypeScript Integration Module
+ *
+ * This module provides TypeScript type resolution for the program graph.
+ * When TypeScript parser services are available, we can:
+ * - Get the type of any expression
+ * - Detect Solid-specific types (Accessor, Signal, Store, Component)
+ * - Mark variables as reactive based on their types
+ */
+
+/**
+ * Type information for a node resolved from TypeScript.
+ *
+ * Provides reactive kind detection, type flags, and serialized type representation.
+ * The `flags` field contains TypeScript's TypeFlags bitmask for the type.
+ */
+interface TypeInfo {
+    raw: string;
+    flags: number;
+    isAccessor: boolean;
+    isSignal: boolean;
+    isStore: boolean;
+    isComponent: boolean;
+}
+/**
+ * Information about a property on an object type.
+ * Used for expanding object spreads into explicit property assignments.
+ */
+interface ObjectPropertyInfo {
+    /** The property name */
+    readonly name: string;
+    /** Whether the property is optional (has ? modifier) */
+    readonly optional: boolean;
+    /** The TypeScript type as a string */
+    readonly type: string;
+}
+/**
+ * Service for resolving TypeScript types from ESLint parser services.
+ */
+declare class TypeResolver {
+    private services;
+    private typeChecker;
+    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;
+    private isSymbolFromSolid;
+    private isSolidSymbol;
+    /**
+     * Check if TypeScript services are available.
+     */
+    hasTypeInfo(): boolean;
+    /**
+     * Get the type info for a node.
+     *
+     * Returns null if TypeScript services are not available or if the type
+     * cannot be determined.
+     */
+    getType(node: TSESTree.Node): TypeInfo | null;
+    /**
+     * Check if a node's type is an Accessor type (Accessor<T>).
+     */
+    isAccessorType(node: TSESTree.Node): boolean;
+    /**
+     * Check if a node's type is a Signal type (Signal<T>).
+     */
+    isSignalType(node: TSESTree.Node): boolean;
+    /**
+     * Check if a node's type is a Store type (Store<T>).
+     */
+    isStoreType(node: TSESTree.Node): boolean;
+    /**
+     * Check if a node's type is a Component type (Component<P>).
+     */
+    isComponentType(node: TSESTree.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;
+    /**
+     * Get both reactive kind AND type info in a single call.
+     */
+    getReactiveKindWithType(node: TSESTree.Node): {
+        kind: ReactiveKind | null;
+        type: TypeInfo | null;
+    };
+    /**
+     * Classify the element type of an array expression.
+     * Uses TypeScript's type system directly.
+     *
+     * @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";
+    /**
+     * Check if a node's type is an array type.
+     * Detects Array<T>, T[], ReadonlyArray<T>, and tuple types.
+     */
+    isArrayType(node: TSESTree.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;
+    /**
+     * Check if a type assertion is unnecessary because the expression
+     * is already assignable to the target type.
+     *
+     * Detects AI slop patterns like:
+     * - `node.left as T.Expression` when node.left is already Expression
+     * - `node.expression as T.Expression` when it's already Expression
+     *
+     * @param expression - The expression being cast
+     * @param targetType - The TypeNode being cast to
+     * @returns true if the cast is unnecessary, false otherwise
+     */
+    isUnnecessaryCast(expression: TSESTree.Expression, targetType: TSESTree.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;
+    /**
+     * Check if a property exists on an object's type.
+     * Handles union types by checking the non-null/undefined constituents.
+     *
+     * @param objectNode The object expression to check
+     * @param propertyName The property name to look for
+     * @returns true if property exists on type, false otherwise
+     */
+    hasPropertyOnType(objectNode: TSESTree.Node, propertyName: string): boolean;
+    /**
+     * Check if a property exists on a type, handling unions specially.
+     */
+    private checkPropertyOnType;
+    /**
+     * Get properties of an object type for spread expansion.
+     * Returns null if the type cannot be safely expanded.
+     *
+     * @param node The AST node to analyze
+     * @param maxProperties Maximum properties to return (default 10)
+     * @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;
+    /**
+     * Extract properties from a TypeScript type.
+     * Returns null for types that can't be safely expanded.
+     *
+     * @param tsType The TypeScript type to extract from
+     * @param maxProperties Maximum number of properties
+     * @param includeCallable Whether to include function-typed properties
+     */
+    private extractObjectProperties;
+    /**
+     * Get the props properties of a Solid component from its JSX tag identifier.
+     *
+     * Resolves the component function's type, gets its first call signature's
+     * first parameter type, and extracts properties from that. This is the
+     * fallback path when the spread argument type itself is unresolvable (e.g.
+     * `any` inside a Show callback) but the component's props type is known.
+     *
+     * @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;
+    private analyzeType;
+    /**
+     * Get aggregated TypeFlags for a type.
+     * For union/intersection types, combines flags from all constituent types.
+     */
+    private getAggregatedFlags;
+    /**
+     * Check if a type is a Solid Accessor type.
+     *
+     * An Accessor<T> is structurally () => T - a zero-parameter callable.
+     * Only uses symbol-based detection to avoid false positives on regular functions.
+     */
+    private isSolidAccessorType;
+    /**
+     * Check if a type is a Solid Signal type.
+     * Detects Signal<T> via symbol or [Accessor<T>, Setter<T>] tuple structure.
+     */
+    private isSolidSignalType;
+    /**
+     * Check if a type is a Solid Store type (for reactive reads).
+     * Excludes SetStoreFunction which is a setter, not a reactive read.
+     */
+    private isSolidStoreType;
+    /**
+     * Check if a type is a Solid Component type.
+     */
+    private isSolidComponentType;
+}
+
+/**
+ * Variable Entity
+ *
+ * Represents a variable binding in the program graph.
+ */
+
+/**
+ * Represents a variable binding in the SolidGraph.
+ */
+interface VariableEntity$1 {
+    id: number;
+    name: string;
+    file: FileEntity$1;
+    scope: ScopeEntity;
+    declarations: TSESTree.Node[];
+    assignments: AssignmentEntity[];
+    reads: ReadEntity[];
+    type: TypeInfo | null;
+    isReactive: boolean;
+    reactiveKind: ReactiveKind | null;
+    isSignalLike: boolean;
+    isMemoVariable: boolean;
+    hasPropertyAssignment: boolean;
+}
+/**
+ * Describes the kind of reactive variable.
+ *
+ * Different kinds have different behaviors and tracking rules.
+ */
+type ReactiveKind = "signal" | "store" | "props" | "memo" | "derived" | "accessor" | "resource";
+/** Assignment operator type extracted from AssignmentExpression */
+type AssignmentOperator = TSESTree.AssignmentExpression["operator"];
+/**
+ * Represents an assignment to a variable.
+ */
+interface AssignmentEntity {
+    id: number;
+    node: TSESTree.Node;
+    /** The assigned value expression */
+    value: TSESTree.Expression;
+    /** The assignment operator ("=" for simple, "+=" etc for compound) */
+    operator: AssignmentOperator | null;
+    /** Whether this assignment is inside a loop */
+    isInLoop: boolean;
+    /** Whether this assignment is inside a conditional (if, switch, ternary, logical) */
+    isInConditional: boolean;
+}
+/**
+ * Represents a location where a variable is read/accessed.
+ */
+interface ReadEntity {
+    id: number;
+    node: TSESTree.Node;
+    scope: ScopeEntity;
+    isProperAccess: boolean;
+    /** Whether this read is inside a loop */
+    isInLoop: boolean;
+    /** Whether this read is inside a conditional (if, switch, ternary, logical) */
+    isInConditional: boolean;
+}
+
+/**
+ * Call Entity
+ *
+ * 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;
+    file: FileEntity$1;
+    callee: CalleeExpression;
+    arguments: ArgumentEntity[];
+    scope: ScopeEntity;
+    resolvedTarget: FunctionEntity | null;
+    /**
+     * The VariableEntity for the root identifier of the callee expression.
+     *
+     * Resolved during the wiring phase by walking the callee's MemberExpression
+     * chain to the leftmost identifier and looking it up in scope.
+     *
+     * - `foo()` → VariableEntity for `foo` (or null if `foo` is a global)
+     * - `obj.method()` → VariableEntity for `obj` (or null if `obj` is global like `console`)
+     * - `a.b.c()` → VariableEntity for `a`
+     * - `getObj().method()` → null (root is a CallExpression, not an Identifier)
+     * - `console.log()` → null (`console` has no user-declared VariableEntity)
+     */
+    calleeRootVariable: VariableEntity$1 | null;
+    primitive: PrimitiveInfo | null;
+    argumentSemantics: ArgumentSemantic[];
+    /** @internal ID of resolved target for deferred resolution */
+    _resolvedTargetId: number;
+}
+/**
+ * Represents a single argument in a call expression.
+ */
+interface ArgumentEntity {
+    id: number;
+    node: TSESTree.Node;
+    index: number;
+    /** Semantic for this argument position, or null if unknown */
+    semantic: ArgumentSemantic | null;
+}
+/**
+ * Semantic information for an argument position.
+ *
+ * Describes how the argument affects reactivity tracking
+ * (tracked, deferred, etc.) and what parameter information is available.
+ */
+interface ArgumentSemantic {
+    position: number;
+    semantic: {
+        type: "tracked";
+    } | {
+        type: "deferred";
+    } | {
+        type: "passthrough";
+    } | {
+        type: "sync";
+    } | {
+        type: "untracked";
+    } | {
+        type: "value";
+    } | {
+        type: "unknown";
+    };
+    parameterSemantics?: ParameterSemantic[];
+}
+/**
+ * Semantic information about a function parameter.
+ */
+interface ParameterSemantic {
+    index: number;
+    isAccessor: boolean;
+    isStore: boolean;
+    description: string;
+}
+/**
+ * Information about a Solid primitive call.
+ */
+interface PrimitiveInfo {
+    name: string;
+    module: "solid-js" | "solid-js/store" | "solid-js/web";
+    returns: PrimitiveReturn;
+}
+/**
+ * Describes the return type of a Solid primitive.
+ */
+type PrimitiveReturn = {
+    type: "signal";
+    writable: boolean;
+} | {
+    type: "accessor";
+} | {
+    type: "store";
+    writable: boolean;
+} | {
+    type: "void";
+} | {
+    type: "owner";
+} | {
+    type: "context";
+} | {
+    type: "resource";
+} | {
+    type: "other";
+};
+
+/**
+ * Return Statement Entity
+ *
+ * Represents a return statement in the program graph.
+ */
+
+/**
+ * Represents a return statement in the SolidGraph.
+ */
+interface ReturnStatementEntity {
+    id: number;
+    node: TSESTree.ReturnStatement;
+    /** The containing function's ID */
+    functionId: number;
+    /** Whether this return has an argument (non-void return) */
+    hasArgument: boolean;
+    /** Whether this is an early return (not the last statement in function body) */
+    isEarly: boolean;
+}
+
+/**
+ * Function Utilities
+ *
+ * Helper functions for working with function nodes.
+ */
+
+type FunctionNode = TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+
+/**
+ * Function Entity
+ *
+ * Represents a function in the program graph.
+ */
+
+/**
+ * Represents a function in the SolidGraph.
+ */
+interface FunctionEntity {
+    id: number;
+    node: FunctionNode;
+    file: FileEntity$1;
+    name: string | null;
+    variableName: string | null;
+    params: ParameterEntity[];
+    body: TSESTree.BlockStatement | TSESTree.Expression;
+    async: boolean;
+    generator: boolean;
+    scope: ScopeEntity;
+    captures: VariableEntity$1[];
+    callSites: CallEntity[];
+    /** True if body contains at least one return with an argument */
+    hasNonVoidReturn: boolean;
+    /** True if body contains at least one throw statement */
+    hasThrowStatement: boolean;
+    /** Character ranges of AwaitExpression nodes directly in this function (not nested functions) */
+    awaitRanges: [number, number][];
+    /** 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;
+    /** All return statements in this function */
+    returnStatements: ReturnStatementEntity[];
+    /** @internal Cached reactive captures for iteration */
+    _cachedReactiveCaptures: VariableEntity$1[] | null;
+    /** Variable entity if this function is assigned to a variable */
+    variable: VariableEntity$1 | null;
+    /** @internal Reachability flags (bitmask) */
+    _reachability: number;
+    /** @internal Cached member accesses indexed by object identifier name */
+    _memberAccessesByIdentifier: Map<string, TSESTree.MemberExpression[]> | null;
+}
+/**
+ * Represents a function parameter.
+ */
+interface ParameterEntity {
+    id: number;
+    node: TSESTree.Parameter;
+    name: string | null;
+    index: number;
+}
+
+/**
+ * JSX Utilities
+ *
+ * Helper functions for working with JSX elements and attributes.
+ */
+
+/**
+ * JSX Attribute Kind (for classification)
+ */
+type JSXAttributeKind = "prop" | "event-handler" | "ref" | "directive" | "spread" | "style" | "class" | "classList";
+
+/**
+ * JSX Entity
+ *
+ * Represents JSX elements in the program graph.
+ */
+
+/**
+ * Represents a JSX element or fragment in the SolidGraph.
+ */
+interface JSXElementEntity {
+    id: number;
+    node: TSESTree.JSXElement | TSESTree.JSXFragment;
+    file: FileEntity$1;
+    tag: string | null;
+    tagName: string | null;
+    isDomElement: boolean;
+    attributes: JSXAttributeEntity[];
+    children: JSXChildEntity[];
+    scope: ScopeEntity;
+    parent: JSXElementEntity | null;
+    childElements: JSXElementEntity[];
+}
+/**
+ * Represents a property extracted from a spread attribute.
+ *
+ * Only populated for literal spreads like `{...{ a: 1, b: 2 }}`.
+ */
+interface SpreadProp {
+    name: string;
+    keyNode: TSESTree.Node;
+    valueNode: TSESTree.Node | null;
+}
+/**
+ * Describes the complexity of a style object.
+ */
+interface StyleComplexityInfo {
+    conditionalCount: number;
+    hasConditionalSpread: boolean;
+}
+/**
+ * Information about spread attributes in JSX.
+ */
+interface SpreadInfo {
+    hasCallExpression: boolean;
+    callExpressionNode: TSESTree.CallExpression | null;
+    hasMemberExpression: boolean;
+    memberExpressionNode: TSESTree.MemberExpression | null;
+    isConditionalSpread: boolean;
+    conditionalSpreadType: "ternary" | "logical-and" | null;
+}
+/**
+ * Represents a JSX attribute on an element.
+ */
+interface JSXAttributeEntity {
+    id: number;
+    node: TSESTree.JSXAttribute | TSESTree.JSXSpreadAttribute;
+    name: string | null;
+    kind: JSXAttributeKind;
+    namespace: string | null;
+    spreadProps: SpreadProp[];
+    valueNode: TSESTree.Node | null;
+    styleComplexity: StyleComplexityInfo | null;
+    spreadInfo: SpreadInfo | null;
+}
+/**
+ * Represents a child node of a JSX element (text, expression, or element).
+ */
+interface JSXChildEntity {
+    id: number;
+    node: TSESTree.Node;
+    kind: "element" | "expression" | "text";
+}
+/**
+ * Describes the context and location of a node within JSX.
+ *
+ * Used to determine if a node is inside JSX and where (attribute, child, expression, etc.).
+ */
+interface JSXContext {
+    element: JSXElementEntity;
+    attribute: JSXAttributeEntity | null;
+    kind: "expression" | "attribute" | "child";
+    containerNode: TSESTree.JSXExpressionContainer | null;
+}
+
+/**
+ * Import Entity
+ *
+ * Represents import declarations in the program graph.
+ */
+
+/**
+ * Represents an import declaration in the SolidGraph.
+ */
+interface ImportEntity {
+    readonly id: number;
+    readonly node: TSESTree.ImportDeclaration;
+    readonly file: FileEntity$1;
+    readonly source: string;
+    readonly specifiers: readonly ImportSpecifierEntity[];
+    readonly isTypeOnly: boolean;
+}
+/**
+ * Represents an individual import specifier within an import declaration.
+ *
+ * Examples:
+ * - `import { foo }` - named specifier
+ * - `import foo from "mod"` - default specifier
+ * - `import * as foo from "mod"` - namespace specifier
+ */
+interface ImportSpecifierEntity {
+    readonly id: number;
+    readonly node: TSESTree.ImportSpecifier | TSESTree.ImportDefaultSpecifier | TSESTree.ImportNamespaceSpecifier;
+    readonly localName: string;
+    readonly importedName: string | null;
+    readonly kind: "named" | "default" | "namespace";
+    readonly isTypeOnly: boolean;
+}
+
+/**
+ * Spread Entity
+ *
+ * Represents spread patterns in the program graph.
+ */
+
+/**
+ * JSX attribute context for specialized handling.
+ * Computed during registration from AST parent structure.
+ */
+type SpreadAttributeContext = "classList" | "style" | "props" | "other";
+/**
+ * Kind of expression being spread.
+ * Computed during registration from spread argument.
+ */
+type SpreadSourceKind = "identifier" | "member" | "call" | "literal" | "logical" | "conditional" | "other";
+/**
+ * Information about a single property in a fixable spread pattern.
+ * Computed during graph building for autofix support.
+ */
+interface FixableSpreadProperty {
+    /** The key text - identifier name or computed expression source */
+    readonly key: string;
+    /** Range of the key expression for source extraction */
+    readonly keyRange: readonly [number, number];
+    /** Whether key is computed [expr] vs static identifier */
+    readonly computed: boolean;
+    /** The value text */
+    readonly value: string;
+    /** Range of the value expression for source extraction */
+    readonly valueRange: readonly [number, number];
+    /** Whether value is literal `true` (common classList pattern) */
+    readonly isBooleanTrue: boolean;
+}
+/**
+ * Pattern info for fixable conditional spreads.
+ * Only populated when the spread has a simple single-property pattern.
+ */
+interface FixableSpreadPattern {
+    /** Which branch has the non-empty object (true = consequent, false = alternate) */
+    readonly truthyBranch: boolean;
+    /** Single property info (only populated if exactly one property) */
+    readonly property: FixableSpreadProperty;
+    /** Range of the condition expression for source extraction */
+    readonly conditionRange: readonly [number, number];
+    /**
+     * Whether condition text matches key text (for computed keys).
+     * When true, `local.class ? { [local.class]: true } : {}` can become `[local.class ?? ""]: true`
+     * instead of `[local.class ?? ""]: !!local.class`.
+     */
+    readonly conditionMatchesKey: boolean;
+}
+/**
+ * Represents a conditional spread pattern in the SolidGraph.
+ *
+ * This includes spreads in any object expression, whether in JSX or standalone.
+ * Patterns detected:
+ * - ...(condition ? {...} : {}) - ternary with empty object fallback
+ * - ...(condition && {...}) - logical AND spread pattern
+ *
+ * For JSX spreads, the node is a JSXSpreadAttribute and parentContext provides
+ * access to the JSX opening element.
+ */
+interface ConditionalSpreadEntity {
+    readonly id: number;
+    /** The spread node - SpreadElement for object spreads, JSXSpreadAttribute for JSX */
+    readonly node: TSESTree.SpreadElement | TSESTree.JSXSpreadAttribute;
+    readonly spreadType: "ternary" | "logical-and";
+    /** The parent object expression (null for JSX spreads) */
+    readonly parentObject: TSESTree.ObjectExpression | null;
+    /** For JSX spreads, the opening element containing the spread attribute */
+    readonly parentJSXElement: TSESTree.JSXOpeningElement | null;
+    readonly isInJSX: boolean;
+    /**
+     * Context where this spread appears.
+     * Enables specialized fix strategies for classList vs style vs generic objects.
+     */
+    readonly attributeContext: SpreadAttributeContext;
+    /**
+     * Fixable pattern info. Null if not a simple fixable pattern.
+     * Only populated for single-property ternary patterns.
+     */
+    readonly fixablePattern: FixableSpreadPattern | null;
+}
+/**
+ * Type of object spread pattern detected.
+ */
+type ObjectSpreadKind = "object-copy" | "object-merge" | "object-update" | "jsx-spread" | "rest-destructure";
+/**
+ * Represents any object spread pattern in the SolidGraph.
+ *
+ * This captures all uses of object spread operator, including:
+ * - Object copying: const copy = { ...original };
+ * - Object merging: const merged = { ...a, ...b };
+ * - Object updating: const updated = { ...obj, prop: value };
+ * - JSX spreads: <div {...props} />
+ * - Rest destructuring: const { a, ...rest } = obj;
+ */
+interface ObjectSpreadEntity {
+    readonly id: number;
+    /** The spread node - SpreadElement, JSXSpreadAttribute, or RestElement */
+    readonly node: TSESTree.SpreadElement | TSESTree.JSXSpreadAttribute | TSESTree.RestElement;
+    /** The kind of spread pattern */
+    readonly kind: ObjectSpreadKind;
+    /** The parent object expression (null for JSX spreads and rest patterns) */
+    readonly parentObject: TSESTree.ObjectExpression | null;
+    /** For JSX spreads, the opening element containing the spread attribute */
+    readonly parentJSXElement: TSESTree.JSXOpeningElement | null;
+    /** The parent pattern for rest destructuring (null otherwise) */
+    readonly parentPattern: TSESTree.ObjectPattern | null;
+    /** True if inside a JSX element */
+    readonly isInJSX: boolean;
+    /** Number of spreads in the same object (for merge detection) */
+    readonly spreadCount: number;
+    /** Number of regular properties in the same object (for update detection) */
+    readonly propertyCount: number;
+    /**
+     * For spreads inside JSX attribute values, which attribute.
+     * Enables specialized messages for classList, style, etc.
+     * Computed from parent chain during registration.
+     */
+    readonly attributeContext: SpreadAttributeContext;
+    /**
+     * Target JSX element tag name if this is a JSX spread.
+     * Examples: "div", "button", "MyComponent"
+     * Computed from parentJSXElement during registration.
+     */
+    readonly targetTag: string | null;
+    /**
+     * Whether target is a native DOM element (lowercase tag).
+     * Used to detect forwarding patterns to native elements.
+     * Computed from targetTag during registration.
+     */
+    readonly targetIsDom: boolean;
+    /**
+     * Name of the spread source for error messages.
+     * Examples: "props", "rest", "store", "local.classList", "signal()"
+     * Computed from spread argument during registration.
+     */
+    readonly sourceName: string | null;
+    /**
+     * Kind of expression being spread.
+     * Used for quick filtering without re-analyzing AST.
+     * Computed from spread argument type during registration.
+     */
+    readonly sourceKind: SpreadSourceKind;
+}
+
+/**
+ * File Entity
+ *
+ * Represents a parsed TypeScript/TSX file in the graph.
+ */
+
+/**
+ * File entity representing a parsed TypeScript/TSX file.
+ *
+ * SourceCode properties (ast, scopeManager, etc.) accessed via sourceCode field.
+ * sourceCode may be null only for internal sentinel files used in fallback scopes.
+ */
+interface FileEntity$1 {
+    id: number;
+    path: string;
+    sourceCode: TSESLint.SourceCode | null;
+    functions: FunctionEntity[];
+    calls: CallEntity[];
+    variables: VariableEntity$1[];
+    scopes: ScopeEntity[];
+    jsxElements: JSXElementEntity[];
+    imports: ImportEntity[];
+    conditionalSpreads: ConditionalSpreadEntity[];
+}
+
+/**
+ * Scope Entity
+ *
+ * Represents a lexical scope in the program graph.
+ */
+
+/**
+ * Represents a lexical scope in the SolidGraph.
+ *
+ * Scopes form a tree structure where each scope has at most one parent
+ * and can have multiple children. Module scope is the root.
+ */
+interface ScopeEntity {
+    id: number;
+    /** The AST node that creates this scope. May be null for fallback/synthetic scopes. */
+    node: TSESTree.Node | null;
+    file: FileEntity$1;
+    kind: "program" | "function" | "block";
+    parent: ScopeEntity | null;
+    children: ScopeEntity[];
+    variables: VariableEntity$1[];
+    functions: FunctionEntity[];
+    trackingContext: TrackingContext | null;
+    isModuleScope: boolean;
+    /** @internal Resolved context (inherited from parent if trackingContext is null) */
+    _resolvedContext: TrackingContext | null;
+    /** @internal Scope chain [self, parent, grandparent, ...] for ancestor iteration */
+    _scopeChain: ScopeEntity[] | null;
+    /** @internal Enclosing component scope if inside a component */
+    _enclosingComponent: {
+        scope: ScopeEntity;
+        name: string;
+    } | null;
+    /** @internal Set of variable names owned by this scope */
+    _ownNames: Set<string> | null;
+    /** @internal Map from variable name to entity for direct lookup */
+    _variablesByName: Map<string, VariableEntity$1> | null;
+    /** @internal Cached descendant scopes */
+    _descendantScopes?: ScopeEntity[];
+}
+/**
+ * Describes the reactivity tracking context for a scope.
+ *
+ * Models Solid.js's runtime tracking semantics:
+ * - tracked: Inside reactive computations (createEffect, createMemo, createRenderEffect)
+ *   where `Listener` is set and signal reads register dependencies
+ * - jsx-expression: Inside JSX expression holes that compile to implicit effects
+ * - deferred: Inside callbacks that execute later (event handlers, onMount, onCleanup)
+ * - component-body: Inside a component function body — runs ONCE in `untrack()`,
+ *   signal reads capture one-time snapshots that never update
+ * - untracked: Explicitly untracked regions (untrack(), createRoot())
+ * - unknown: Context cannot be determined
+ */
+interface TrackingContext {
+    type: "tracked" | "jsx-expression" | "deferred" | "component-body" | "untracked" | "unknown";
+    source?: string;
+    reason?: string;
+}
+
+/**
+ * Export Entity
+ *
+ * Represents an exported symbol from a file.
+ * Tracks the relationship to the underlying entity (function/variable)
+ * and provides metadata for cross-file analysis.
+ */
+
+/**
+ * Export kind classification.
+ * Matches ganko's ExportKind for compatibility.
+ */
+declare enum ExportKind {
+    FUNCTION = 0,
+    VARIABLE = 1,
+    COMPONENT = 2,
+    CLASS = 3,
+    TYPE = 4,
+    SIGNAL = 5,
+    STORE = 6,
+    MEMO = 7,
+    RESOURCE = 8
+}
+/**
+ * Represents a single export from a file.
+ */
+interface ExportEntity {
+    /** Unique ID within the graph */
+    readonly id: number;
+    /** Export name (or "default" for default export, "*" for namespace re-export) */
+    readonly name: string;
+    /** Classification of the export */
+    readonly kind: ExportKind;
+    /**
+     * Entity ID of the underlying function or variable.
+     * -1 for type-only exports or external re-exports.
+     */
+    readonly entityId: number;
+    /** Whether this is a type-only export */
+    readonly isTypeOnly: boolean;
+    /** Whether this is the default export */
+    readonly isDefault: boolean;
+    /** Reactive kind if this exports a reactive value */
+    readonly reactiveKind: ReactiveKind | null;
+    /**
+     * Signature string for change detection.
+     * Used by workspace layer to detect export API changes.
+     * Format: "fn:2" (function with 2 params), "var:signal", etc.
+     */
+    readonly signature: string;
+    /** AST node for go-to-definition */
+    readonly node: TSESTree.Node;
+    /** Location for quick access */
+    readonly loc: TSESTree.SourceLocation | null;
+    /**
+     * Source module for re-exports, null for local exports.
+     * Set for `export { X } from "./mod"` and `export * from "./mod"`.
+     */
+    readonly source: string | null;
+    /**
+     * Original name in source module for re-exports, null for local exports.
+     * For `export { foo as bar } from "./mod"`, this is "foo".
+     */
+    readonly importedName: string | null;
+}
+
+/**
+ * Property Entity
+ *
+ * Represents a class property in the program graph.
+ */
+
+/**
+ * Represents a class property in the SolidGraph.
+ */
+interface PropertyEntity {
+    id: number;
+    node: TSESTree.PropertyDefinition;
+    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;
+}
+
+/**
+ * Class Entity
+ *
+ * Represents a class in the program graph.
+ */
+
+type ClassNode = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+/**
+ * Represents a class in the SolidGraph.
+ */
+interface ClassEntity {
+    id: number;
+    node: ClassNode;
+    file: FileEntity$1;
+    name: string | null;
+    methods: FunctionEntity[];
+    properties: PropertyEntity[];
+    constructor: FunctionEntity | null;
+    abstract: boolean;
+    /** The declaration node for JSDoc attachment (export wrapper or self) */
+    declarationNode: TSESTree.Node;
+    /** @internal Variable entity if this class is assigned to a variable */
+    _variable: VariableEntity$1 | null;
+}
+
+/**
+ * Property Assignment Entity
+ *
+ * Represents property assignments (obj.prop = value) in the program graph.
+ * These are distinct from variable assignments and are tracked separately
+ * because they can cause V8 hidden class transitions.
+ */
+
+/**
+ * Represents a property assignment expression in the SolidGraph.
+ *
+ * Tracks assignments where the left-hand side is a MemberExpression:
+ * - `obj.prop = value`
+ * - `obj[key] = value`
+ */
+interface PropertyAssignmentEntity {
+    readonly id: number;
+    /** The AssignmentExpression node */
+    readonly node: TSESTree.AssignmentExpression;
+    /** The MemberExpression on the left side */
+    readonly target: TSESTree.MemberExpression;
+    /** The object being assigned to */
+    readonly object: TSESTree.Expression;
+    /** The property name (if computed, this may be an expression) */
+    readonly property: TSESTree.Expression | TSESTree.PrivateIdentifier;
+    /** Whether property is computed (obj[prop] vs obj.prop) */
+    readonly computed: boolean;
+    /** The assigned value expression */
+    readonly value: TSESTree.Expression;
+    /** The assignment operator */
+    readonly operator: TSESTree.AssignmentExpression["operator"];
+    /** Containing scope */
+    readonly scope: ScopeEntity;
+    /** Containing file */
+    readonly file: FileEntity$1;
+    /** Whether inside a loop */
+    readonly isInLoop: boolean;
+    /** Whether inside a conditional */
+    readonly isInConditional: boolean;
+    /** Whether the property exists on the object's declared type (mutation vs addition) */
+    readonly propertyExistsOnType: boolean;
+    /** Whether this is an array index assignment (arr[i] = value) */
+    readonly isArrayIndexAssignment: boolean;
+    /** Whether the property name is dynamic and cannot be statically determined */
+    readonly hasDynamicPropertyName: boolean;
+}
+
+/**
+ * Non-Null Assertion Entity
+ *
+ * Represents a TSNonNullExpression (the `!` operator) in the program graph.
+ */
+
+/**
+ * Represents a non-null assertion expression (`expr!`) in the SolidGraph.
+ */
+interface NonNullAssertionEntity {
+    readonly id: number;
+    /** The TSNonNullExpression node */
+    readonly node: TSESTree.TSNonNullExpression;
+    /** The expression being asserted as non-null */
+    readonly expression: TSESTree.Expression;
+}
+
+/**
+ * Type Assertion Entity
+ *
+ * Represents type assertions in the program graph, including:
+ * - `as` assertions: `x as Type`
+ * - Double assertions: `x as unknown as Type`
+ * - Angle bracket assertions: `<Type>x`
+ * - `as any` casts
+ */
+
+/**
+ * The kind of type assertion being performed.
+ */
+type TypeAssertionKind = "simple" | "double" | "cast-to-any" | "cast-to-unknown" | "const-assertion";
+/**
+ * Represents a type assertion expression in the SolidGraph.
+ *
+ * Covers both `as` expressions and angle bracket syntax.
+ */
+interface TypeAssertionEntity {
+    readonly id: number;
+    /** The assertion node (TSAsExpression or TSTypeAssertion) */
+    readonly node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+    /** The expression being cast */
+    readonly expression: TSESTree.Expression;
+    /** The type being cast to */
+    readonly typeAnnotation: TSESTree.TypeNode;
+    /** The kind of assertion */
+    readonly kind: TypeAssertionKind;
+    /** Whether this is inside a loop */
+    readonly inLoop: boolean;
+    /** Whether this assertion is on an import expression (dynamic or static) */
+    readonly onImport: boolean;
+    /** The scope containing this assertion */
+    readonly scope: ScopeEntity;
+    /** For double assertions, reference to the inner assertion if present */
+    readonly innerAssertion: TypeAssertionEntity | null;
+    /**
+     * Whether the cast is unnecessary because the expression type is
+     * already assignable to the target type. Set during wiring phase
+     * when TypeScript type info is available. null if unknown.
+     */
+    isUnnecessary: boolean | null;
+    /**
+     * The actual type of the expression (for error messages).
+     * Set during wiring phase when TypeScript type info is available.
+     */
+    expressionType: string | null;
+}
+/**
+ * Represents a type predicate function (function with `is` keyword).
+ */
+interface TypePredicateEntity {
+    readonly id: number;
+    /** The function node */
+    readonly node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+    /** The parameter name being narrowed */
+    readonly parameterName: string;
+    /** The type being asserted */
+    readonly typeAnnotation: TSESTree.TypeNode;
+}
+/**
+ * Represents a generic function with type assertion in its return.
+ *
+ * Detects patterns like:
+ * ```ts
+ * function getData<T>(id: string): T {
+ *   return JSON.parse(apiCall(id)) as T;
+ * }
+ * ```
+ */
+interface UnsafeGenericAssertionEntity {
+    readonly id: number;
+    /** The function node */
+    readonly node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression;
+    /** The generic type parameter being asserted to */
+    readonly typeParameterName: string;
+    /** The type assertion node within the function */
+    readonly assertion: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+}
+/**
+ * Where in the program an unsafe type annotation appears.
+ *
+ * - "parameter": function/method parameter type (`function foo(x: any)`)
+ * - "return": function/method return type (`function foo(): unknown`)
+ * - "variable": variable declaration type (`let x: any`)
+ * - "property": class/object property type (`class Foo { x: any }`)
+ * - "generic-constraint": generic type constraint (`<T extends unknown>`)
+ */
+type UnsafeAnnotationPosition = "parameter" | "return" | "variable" | "property" | "generic-constraint";
+/**
+ * Whether the annotation is `any` or `unknown`.
+ */
+type UnsafeAnnotationKind = "any" | "unknown";
+/**
+ * Represents an unsafe type annotation (`any` or `unknown`) in a value-level position.
+ *
+ * This entity is NOT created for:
+ * - Type alias bodies (`type Foo = unknown`) — type-level, not value-level
+ * - Interface definitions (`interface Foo { [key: string]: unknown }`) — structural types
+ * - Catch clause parameters (`catch (e: unknown)`) — recommended by TypeScript
+ * - Generic constraints on type parameters (`<T extends unknown>`) with `unknown` — vacuously true
+ * - `Record<string, unknown>` pattern — standard generic constraint pattern
+ */
+interface UnsafeTypeAnnotationEntity {
+    readonly id: number;
+    /** The TSAnyKeyword or TSUnknownKeyword node */
+    readonly node: TSESTree.TSAnyKeyword | TSESTree.TSUnknownKeyword;
+    /** Whether this is `any` or `unknown` */
+    readonly kind: UnsafeAnnotationKind;
+    /** Where the annotation appears */
+    readonly position: UnsafeAnnotationPosition;
+    /**
+     * Name context for error messages.
+     * For parameters: the parameter name.
+     * For returns: the function name.
+     * For variables: the variable name.
+     * For properties: the property name.
+     * For generic constraints: the type parameter name.
+     */
+    readonly name: string | null;
+    /** The containing function name (for parameters/returns), or null */
+    readonly functionName: string | null;
+}
+
+/**
+ * Inline Import Entity
+ *
+ * Represents TSImportType nodes (inline type imports) in the program graph.
+ * Example: `import("@typescript-eslint/utils").TSESLint.RuleFixer`
+ */
+
+/**
+ * Represents an inline type import in the SolidGraph.
+ *
+ * Inline imports use the `import("module").Type` syntax rather than
+ * top-level import declarations. These should typically be refactored
+ * to use proper import statements for better readability.
+ */
+interface InlineImportEntity {
+    readonly id: number;
+    /** The TSImportType node */
+    readonly node: TSESTree.TSImportType;
+    /** The file containing this inline import */
+    readonly file: FileEntity$1;
+    /** The module specifier being imported (e.g., "@typescript-eslint/utils") */
+    readonly source: string;
+    /** The qualified path after the import (e.g., "TSESLint.RuleFixer") */
+    readonly qualifier: string;
+}
+
+/**
+ * Computation Entity
+ *
+ * Unified representation of a reactive computation node in the
+ * dependency graph. Maps to Solid's runtime Computation interface:
+ * createEffect, createMemo, createComputed, createRenderEffect,
+ * createResource, and createRoot.
+ *
+ * A computation has:
+ * - A backing CallEntity (the primitive invocation)
+ * - A callback FunctionEntity (the tracked/deferred body)
+ * - Dependencies: signals/memos/stores it reads (over-approximated statically)
+ * - An owner: the parent computation or root that owns it for disposal
+ */
+
+/**
+ * Discriminates the scheduling behavior of a computation.
+ *
+ * - `"effect"` — createEffect: pure=false, user=true, deferred to Effects queue
+ * - `"render-effect"` — createRenderEffect: pure=false, user=false, immediate
+ * - `"computed"` — createComputed: pure=true, synchronous
+ * - `"memo"` — createMemo: pure=true, dual node (also a signal source)
+ * - `"resource"` — createResource: async, internally creates signals + computed
+ * - `"root"` — createRoot: ownership boundary, no tracking
+ * - `"reaction"` — createReaction: split tracking (track fn separate from effect fn)
+ */
+type ComputationKind = "effect" | "render-effect" | "computed" | "memo" | "resource" | "root" | "reaction";
+/**
+ * Represents a reactive computation in the SolidGraph.
+ */
+interface ComputationEntity {
+    readonly id: number;
+    readonly kind: ComputationKind;
+    /** The primitive call that created this computation. */
+    readonly call: CallEntity;
+    /** The callback function body (tracked or deferred). Null for createRoot with no-arg fn. */
+    readonly callback: FunctionEntity | null;
+    /** The scope this computation's callback runs in. */
+    readonly scope: ScopeEntity;
+    /** Variable this computation is assigned to (e.g. the memo accessor, resource tuple). */
+    readonly variable: VariableEntity$1 | null;
+    /** Whether this computation is a signal source (readable by other computations). */
+    readonly isSource: boolean;
+    /** Whether this computation runs in a tracked context (Listener is set). */
+    readonly isTracked: boolean;
+}
+/**
+ * A dependency edge: computation reads a reactive source.
+ *
+ * Static over-approximation — any signal-like variable syntactically
+ * reachable from the computation's callback body is included,
+ * regardless of runtime control flow.
+ */
+interface DependencyEdge {
+    /** The computation that reads the source. */
+    readonly consumer: ComputationEntity;
+    /** The reactive variable being read. */
+    readonly source: VariableEntity$1;
+    /** Whether the read is a proper accessor call (e.g. `count()` vs bare `count`). */
+    readonly isProperAccess: boolean;
+    /** Whether the read is inside an untrack() call within the computation. */
+    readonly isUntracked: boolean;
+    /**
+     * For store/props sources: the property access path (e.g. `["foo", "bar"]`
+     * for `store.foo.bar`). Null for signal/memo reads or when the access
+     * is dynamic and cannot be statically determined.
+     */
+    readonly propertyPath: readonly string[] | null;
+}
+/**
+ * An ownership edge: parent computation owns a child computation.
+ *
+ * Models Solid's runtime Owner tree — when a parent is disposed,
+ * all children are recursively disposed. This is structural
+ * (lexical nesting at creation time), not behavioral.
+ */
+interface OwnershipEdge {
+    /** The parent owner (computation or root). */
+    readonly owner: ComputationEntity;
+    /** The child computation owned by the parent. */
+    readonly child: ComputationEntity;
+}
+
+/**
+ * SolidGraph Implementation
+ */
+
+/** @internal */
+interface JSXAttributeWithElement {
+    readonly attr: JSXAttributeEntity;
+    readonly element: JSXElementEntity;
+}
+interface JSXStaticClassIndex {
+    readonly hasDynamicClass: boolean;
+    readonly tokens: readonly string[];
+}
+interface JSXStaticObjectKeyIndex {
+    readonly hasDynamic: boolean;
+    readonly keys: readonly string[];
+}
+interface JSXObjectPropertyWithElement {
+    readonly property: TSESTree.ObjectLiteralElementLike;
+    readonly attr: JSXAttributeEntity;
+    readonly element: JSXElementEntity;
+}
+/**
+ * The Solid.js program graph implementation.
+ *
+ * Contains all entities extracted from a Solid.js source file:
+ * scopes, variables, functions, calls, JSX elements, imports, exports, etc.
+ *
+ */
+declare class SolidGraph {
+    readonly kind: "solid";
+    readonly file: string;
+    readonly logger: Logger;
+    readonly sourceCode: TSESLint.SourceCode;
+    readonly typeResolver: TypeResolver;
+    readonly fileEntity: FileEntity$1;
+    private _nextScopeId;
+    private _nextVariableId;
+    private _nextFunctionId;
+    private _nextCallId;
+    private _nextJsxId;
+    private _nextImportId;
+    private _nextExportId;
+    private _nextClassId;
+    private _nextPropertyId;
+    private _nextConditionalSpreadId;
+    private _nextMiscId;
+    readonly scopes: ScopeEntity[];
+    readonly variables: VariableEntity$1[];
+    readonly functions: FunctionEntity[];
+    readonly calls: CallEntity[];
+    readonly jsxElements: JSXElementEntity[];
+    readonly imports: ImportEntity[];
+    readonly exports: ExportEntity[];
+    readonly classes: ClassEntity[];
+    readonly properties: PropertyEntity[];
+    readonly propertyAssignments: PropertyAssignmentEntity[];
+    readonly conditionalSpreads: ConditionalSpreadEntity[];
+    readonly objectSpreads: ObjectSpreadEntity[];
+    readonly nonNullAssertions: NonNullAssertionEntity[];
+    readonly typeAssertions: TypeAssertionEntity[];
+    readonly typePredicates: TypePredicateEntity[];
+    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 functionsByName: Map<string, FunctionEntity[]>;
+    readonly callsByNode: Map<TSESTree.CallExpression | TSESTree.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 jsxByTag: Map<string, JSXElementEntity[]>;
+    readonly jsxAttributesByElementId: Map<number, ReadonlyMap<string, JSXAttributeEntity>>;
+    readonly jsxAttrsByKind: Map<JSXAttributeKind, JSXAttributeWithElement[]>;
+    readonly jsxClassAttributes: JSXAttributeWithElement[];
+    readonly jsxClassListAttributes: JSXAttributeWithElement[];
+    readonly jsxStyleAttributes: JSXAttributeWithElement[];
+    readonly fillImageElements: JSXElementEntity[];
+    readonly staticClassTokensByElementId: Map<number, JSXStaticClassIndex>;
+    readonly staticClassListKeysByElementId: Map<number, JSXStaticObjectKeyIndex>;
+    readonly staticStyleKeysByElementId: Map<number, JSXStaticObjectKeyIndex>;
+    readonly classListProperties: JSXObjectPropertyWithElement[];
+    readonly styleProperties: JSXObjectPropertyWithElement[];
+    /** CSS class names defined in inline `<style>` elements within JSX (e.g., SVG icons with embedded CSS). */
+    readonly inlineStyleClassNames: Set<string>;
+    readonly importsBySource: Map<string, ImportEntity[]>;
+    readonly exportsByName: Map<string, ExportEntity>;
+    readonly exportsByEntityId: Map<number, ExportEntity>;
+    readonly classesByNode: Map<TSESTree.ClassDeclaration | TSESTree.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;
+    firstScope: ScopeEntity | null;
+    readonly componentScopes: Map<ScopeEntity, {
+        scope: ScopeEntity;
+        name: string;
+    }>;
+    componentFunctions: FunctionEntity[];
+    functionsWithReactiveCaptures: FunctionEntity[];
+    reactiveVariables: VariableEntity$1[];
+    propsVariables: VariableEntity$1[];
+    storeVariables: VariableEntity$1[];
+    resourceVariables: VariableEntity$1[];
+    variablesWithPropertyAssignment: VariableEntity$1[];
+    /** Reactive computation nodes (effects, memos, computed, roots, resources). */
+    computations: ComputationEntity[];
+    /** Computation lookup by CallEntity ID. */
+    readonly computationByCallId: Map<number, ComputationEntity>;
+    /** Dependency edges: computation reads reactive source. */
+    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>;
+    /**
+     * Creates a new SolidGraph instance.
+     *
+     * @param input - The graph input containing source code and parser services
+     */
+    constructor(input: SolidInput);
+    /** @internal Generate next scope ID */
+    nextScopeId(): number;
+    /** @internal Generate next variable ID */
+    nextVariableId(): number;
+    /** @internal Generate next function ID */
+    nextFunctionId(): number;
+    /** @internal Generate next call ID */
+    nextCallId(): number;
+    /** @internal Generate next JSX element ID */
+    nextJsxId(): number;
+    /** @internal Generate next import ID */
+    nextImportId(): number;
+    /** @internal Generate next export ID */
+    nextExportId(): number;
+    /** @internal Generate next class ID */
+    nextClassId(): number;
+    /** @internal Generate next property ID */
+    nextPropertyId(): number;
+    /** @internal Generate next conditional spread ID */
+    nextConditionalSpreadId(): number;
+    /** @internal Generate next misc entity ID */
+    nextMiscId(): number;
+    /**
+     * @internal Add a scope entity to the graph. Called by scopesPhase.
+     */
+    addScope(scope: ScopeEntity, eslintScope: TSESLint.Scope.Scope): void;
+    /**
+     * @internal Add a variable entity to the graph. Called by scopesPhase.
+     */
+    addVariable(variable: VariableEntity$1): void;
+    /**
+     * @internal Add a function entity to the graph. Called by entitiesPhase.
+     */
+    addFunction(fn: FunctionEntity): void;
+    /**
+     * @internal Add a call entity to the graph. Called by entitiesPhase.
+     */
+    addCall(call: CallEntity): void;
+    /**
+     * @internal Add a JSX element entity to the graph. Called by entitiesPhase.
+     */
+    addJSXElement(element: JSXElementEntity): void;
+    /**
+     * Extract CSS class names from inline `<style>` JSX elements.
+     *
+     * Handles patterns like `<style>{`.foo { ... }`}</style>` found in SVG icons.
+     * Scans template literal and literal string children for `.className` patterns.
+     */
+    private extractInlineStyleClassNames;
+    private indexObjectAttribute;
+    /**
+     * @internal Add an import entity to the graph. Called by entitiesPhase.
+     */
+    addImport(imp: ImportEntity): void;
+    /**
+     * @internal Add an export entity to the graph. Called by exportsPhase.
+     */
+    addExport(exp: ExportEntity): void;
+    /** @internal Add a class entity to the graph. Called by entitiesPhase. */
+    addClass(cls: ClassEntity): void;
+    /** @internal Add a property entity to the graph. */
+    addProperty(prop: PropertyEntity): void;
+    /** @internal Add a property assignment entity to the graph. */
+    addPropertyAssignment(pa: PropertyAssignmentEntity): void;
+    /** @internal Add a conditional spread entity to the graph. */
+    addConditionalSpread(spread: ConditionalSpreadEntity): void;
+    /** @internal Add an object spread entity to the graph. */
+    addObjectSpread(spread: ObjectSpreadEntity): void;
+    /** @internal Add a non-null assertion entity to the graph. */
+    addNonNullAssertion(assertion: NonNullAssertionEntity): void;
+    /** @internal Add a type assertion entity to the graph. */
+    addTypeAssertion(assertion: TypeAssertionEntity): void;
+    /** @internal Add a type predicate entity to the graph. */
+    addTypePredicate(predicate: TypePredicateEntity): void;
+    /** @internal Add an unsafe generic assertion entity to the graph. */
+    addUnsafeGenericAssertion(assertion: UnsafeGenericAssertionEntity): void;
+    /** @internal Add an unsafe type annotation entity to the graph. */
+    addUnsafeTypeAnnotation(annotation: UnsafeTypeAnnotationEntity): void;
+    /** @internal Add an inline import entity to the graph. */
+    addInlineImport(imp: InlineImportEntity): void;
+    /** @internal Add a computation entity to the graph. Called by dependenciesPhase. */
+    addComputation(computation: ComputationEntity): void;
+    /** @internal Add a dependency edge to the graph. Called by dependenciesPhase. */
+    addDependencyEdge(edge: DependencyEdge): void;
+    /** @internal Add an ownership edge to the graph. Called by dependenciesPhase. */
+    addOwnershipEdge(edge: OwnershipEdge): void;
+    /**
+     * @internal Build reactive variable indexes. Called by reactivityPhase.
+     */
+    buildReactiveIndex(): void;
+    /** @internal */
+    addUnaryExpression(node: TSESTree.UnaryExpression): void;
+    /** @internal */
+    addSpreadElement(node: TSESTree.SpreadElement): void;
+    /** @internal */
+    addNewExpressionByCallee(name: string, node: TSESTree.NewExpression): 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[];
+}
+
+/**
+ * Validates whether a CSS class name is a known Tailwind utility.
+ *
+ * Implementations are provided by callers depending on their execution
+ * context (async vs sync). The CSSGraph stores this as an optional field
+ * and the undefined-css-class rule falls back to it when `classNameIndex`
+ * misses.
+ */
+interface TailwindValidator {
+    has(className: string): boolean;
+    /**
+     * Resolves a Tailwind utility class to its generated CSS string.
+     *
+     * Returns the full CSS rule text (e.g. `.flex { display: flex; }`) or null
+     * if the class is not a valid Tailwind utility or resolution is not supported
+     * (e.g. in the sync/static validator path).
+     */
+    resolve(className: string): string | null;
+}
+/**
+ * Resolves a TailwindValidator from CSS files by detecting Tailwind v4
+ * and loading the design system via `@tailwindcss/node`.
+ *
+ * Handles projects where `@tailwindcss/node` is a transitive dependency
+ * (e.g. installed via `@tailwindcss/vite`) by resolving through carrier
+ * packages when direct import fails.
+ *
+ * Returns null if:
+ * - No Tailwind entry file is detected
+ * - `@tailwindcss/node` is not installed (directly or transitively)
+ * - The design system fails to load
+ */
+declare function resolveTailwindValidator(files: readonly {
+    path: string;
+    content: string;
+}[]): Promise<TailwindValidator | null>;
+
+/**
+ * CSSInput - Input type for building CSSGraph from CSS/SCSS source files.
+ *
+ * This defines the contract for what data is needed to build a CSS
+ * program graph. Unlike SolidInput which handles single files via ESLint,
+ * CSSInput supports multi-file graphs with explicit file content.
+ */
+
+/**
+ * A single CSS/SCSS file to be processed.
+ */
+interface CSSFile {
+    /** File path (used for error reporting and import resolution) */
+    readonly path: string;
+    /** Raw file content */
+    readonly content: string;
+}
+/**
+ * Input for building a CSSGraph from CSS/SCSS source files.
+ */
+interface CSSInput {
+    /** Files to process */
+    readonly files: readonly CSSFile[];
+    /** Optional build options */
+    readonly options?: CSSOptions;
+    /** Pre-resolved Tailwind validator for utility class validation */
+    readonly tailwind?: TailwindValidator;
+    /** Logger for diagnostic output from CSS rules */
+    readonly logger?: Logger;
+    /**
+     * CSS custom property names provided by external libraries at runtime.
+     *
+     * These are discovered by scanning dependency packages for CSS custom property
+     * definitions injected via JavaScript (e.g., inline style attributes in JSX).
+     * Properties in this set are registered in the CSS graph as globally-scoped
+     * definitions so the resolution engine treats them as defined.
+     *
+     * Use `scanDependencyCustomProperties()` from `./library-analysis` to populate this.
+     */
+    readonly externalCustomProperties?: ReadonlySet<string>;
+}
+/**
+ * Options for CSS graph building.
+ */
+interface CSSOptions {
+    /** Enable SCSS parsing (default: auto-detect from extension) */
+    readonly scss?: boolean;
+    /** Enable theme token inference (default: true) */
+    readonly inferTokens?: boolean;
+    /** Enable cascade analysis (default: true) */
+    readonly analyzeCascade?: boolean;
+    /** Enable dead code detection (default: false) */
+    readonly detectDeadCode?: boolean;
+    /** Custom token naming patterns */
+    readonly tokenPatterns?: TokenPatternConfig;
+    /** Maximum parse errors before stopping (default: unlimited) */
+    readonly maxParseErrors?: number;
+    /** Error reporting mode (default: "collect") */
+    readonly errorReporting?: "silent" | "collect" | "throw";
+}
+/**
+ * Configuration for token naming pattern detection.
+ */
+interface TokenPatternConfig {
+    readonly color?: readonly RegExp[];
+    readonly spacing?: readonly RegExp[];
+    readonly typography?: readonly RegExp[];
+    readonly custom?: readonly {
+        category: string;
+        patterns: readonly RegExp[];
+    }[];
+}
+
+/**
+ * CSS Specificity Types
+ */
+/**
+ * CSS specificity tuple [inline, id, class, element].
+ * Inline is always 0 in stylesheets (only 1 for inline styles).
+ */
+type Specificity = readonly [number, number, number, number];
+
+/**
+ * CSS Value Parsing Utilities
+ *
+ * Functions for parsing and analyzing CSS values using postcss-value-parser.
+ */
+/**
+ * Parsed CSS value with component breakdown.
+ */
+interface ParsedValue {
+    nodes: ParsedValueNode[];
+    hasCalc: boolean;
+    hasVar: boolean;
+    hasUrl: boolean;
+    hasFunction: boolean;
+    colors: string[];
+    units: string[];
+}
+/**
+ * A node in a parsed CSS value.
+ */
+interface ParsedValueNode {
+    type: "word" | "string" | "function" | "space" | "div" | "comment";
+    value: string;
+    sourceIndex: number;
+}
+/**
+ * A var() reference extracted from a CSS value.
+ */
+interface VarReference {
+    name: string;
+    fallback: string | null;
+    sourceIndex: number;
+    raw: string;
+}
+/**
+ * Information about a function call in a CSS value.
+ */
+interface FunctionCallInfo {
+    name: string;
+    arguments: string[];
+    raw: string;
+    sourceIndex: number;
+}
+
+/**
+ * CSS Theme Token Types
+ */
+
+/**
+ * Token category for design system organization.
+ */
+type TokenCategory = "color" | "spacing" | "typography" | "border" | "shadow" | "radius" | "z-index" | "animation" | "breakpoint" | "other";
+/**
+ * Theme token variant (e.g., "500", "light", "hover").
+ */
+interface ThemeTokenVariant {
+    name: string;
+    variable: VariableEntity;
+    value: string;
+}
+/**
+ * Represents a theme/design system token.
+ */
+interface ThemeTokenEntity {
+    id: number;
+    name: string;
+    category: TokenCategory;
+    file: FileEntity;
+    variables: VariableEntity[];
+    variants: ThemeTokenVariant[];
+    isComplete: boolean;
+    missingVariants: string[];
+    namingPattern: string;
+}
+
+/**
+ * CSS Value Types
+ */
+
+/**
+ * Position in the CSS cascade.
+ */
+interface CascadePosition {
+    layer: string | null;
+    layerOrder: number;
+    sourceOrder: number;
+    specificity: Specificity;
+    specificityScore: number;
+    isImportant: boolean;
+}
+
+/**
+ * CSS Variable Types
+ */
+
+/**
+ * Variable scope information.
+ */
+interface VariableScope {
+    type: "global" | "selector" | "media" | "supports" | "layer";
+    condition: string | null;
+    specificity: Specificity | null;
+}
+/**
+ * Represents a CSS custom property definition (--name: value).
+ */
+interface VariableEntity {
+    id: number;
+    name: string;
+    declaration: DeclarationEntity;
+    file: FileEntity;
+    scope: VariableScope;
+    scopeSelector: SelectorEntity | null;
+    _flags: number;
+    value: string;
+    parsedValue: ParsedValue;
+    computedValue: string | null;
+    references: VariableReferenceEntity[];
+    shadows: VariableEntity[];
+    shadowedBy: VariableEntity[];
+    themeToken: ThemeTokenEntity | null;
+    scssName: string | null;
+}
+/**
+ * Represents a var(--name) usage.
+ */
+interface VariableReferenceEntity {
+    id: number;
+    name: string;
+    declaration: DeclarationEntity;
+    file: FileEntity;
+    resolvedVariable: VariableEntity | null;
+    _flags: number;
+    fallback: string | null;
+    fallbackReferences: VariableReferenceEntity[];
+    fallbackChainDepth: number;
+    sourceIndex: number;
+    raw: string;
+}
+
+/**
+ * CSS Declaration Entity
+ */
+
+/**
+ * Represents a CSS declaration (property: value).
+ */
+interface DeclarationEntity {
+    id: number;
+    node: Declaration;
+    rule: RuleEntity | null;
+    file: FileEntity;
+    property: string;
+    value: string;
+    rawValue: string;
+    _flags: number;
+    parsedValue: ParsedValue;
+    variableRefs: VariableReferenceEntity[];
+    functionCalls: FunctionCallInfo[];
+    parsedVarRefs: VarReference[];
+    startLine: number;
+    startColumn: number;
+    startOffset: number;
+    endOffset: number;
+    sourceOrder: number;
+    cascadePosition: CascadePosition;
+    overrides: DeclarationEntity[];
+    overriddenBy: DeclarationEntity[];
+}
+
+/**
+ * CSS At-Rule Types
+ */
+
+/**
+ * Discriminator for common at-rule types.
+ */
+type AtRuleKind = "media" | "keyframes" | "font-face" | "supports" | "import" | "layer" | "container" | "page" | "charset" | "namespace" | "mixin" | "function" | "include" | "extend" | "use" | "forward" | "other";
+/**
+ * Media condition for @media rules.
+ */
+interface MediaCondition {
+    type: "all" | "screen" | "print" | "speech";
+    features: MediaFeature[];
+    isNot: boolean;
+}
+/**
+ * Media feature within a media condition.
+ */
+interface MediaFeature {
+    name: string;
+    value: string | null;
+    operator: "min" | "max" | "exact" | null;
+}
+/**
+ * Parsed at-rule parameters.
+ */
+interface ParsedAtRuleParams {
+    raw: string;
+    mediaConditions?: MediaCondition[];
+    animationName?: string;
+    fontFamily?: string;
+    layerName?: string;
+    layerNames?: string[];
+    containerName?: string;
+    containerCondition?: string;
+}
+/**
+ * Represents a CSS at-rule (@media, @keyframes, etc.).
+ */
+interface AtRuleEntity {
+    id: number;
+    node: AtRule;
+    file: FileEntity;
+    name: string;
+    kind: AtRuleKind;
+    params: string;
+    parsedParams: ParsedAtRuleParams;
+    rules: RuleEntity[];
+    declarations: DeclarationEntity[];
+    nestedAtRules: AtRuleEntity[];
+    parent: RuleEntity | AtRuleEntity | null;
+    depth: number;
+    startLine: number;
+    endLine: number;
+    sourceOrder: number;
+}
+
+/**
+ * CSS File Entity
+ */
+
+/**
+ * Import information for @import/@use directives.
+ */
+interface ImportInfo {
+    path: string;
+    node: AtRule;
+    isPartial: boolean;
+    resolvedFile: FileEntity | null;
+    mediaQuery: string | null;
+    layer: string | null;
+}
+/**
+ * Represents a CSS/SCSS source file.
+ */
+interface FileEntity {
+    id: number;
+    path: string;
+    content: string;
+    syntax: "css" | "scss" | "sass" | "less";
+    node: Root;
+    lineCount: number;
+    lineStartOffsets: readonly number[];
+    _flags: number;
+    imports: ImportInfo[];
+    importedBy: FileEntity[];
+    rules: RuleEntity[];
+    atRules: AtRuleEntity[];
+    variables: VariableEntity[];
+}
+
+/**
+ * CSS Rule Entity
+ */
+
+/**
+ * Represents a CSS rule (selector block with declarations).
+ */
+interface RuleEntity {
+    kind: "rule";
+    id: number;
+    node: Rule;
+    file: FileEntity;
+    selectorText: string;
+    selectors: SelectorEntity[];
+    declarations: DeclarationEntity[];
+    nestedRules: RuleEntity[];
+    nestedAtRules: AtRuleEntity[];
+    parent: RuleEntity | AtRuleEntity | null;
+    depth: number;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    startOffset: number;
+    endOffset: number;
+    blockStartOffset: number;
+    blockEndOffset: number;
+    sourceOrder: number;
+    containingMedia: AtRuleEntity | null;
+    containingLayer: AtRuleEntity | null;
+    containingMediaStack: AtRuleEntity[];
+    declarationIndex: Map<string, DeclarationEntity[]>;
+    /** Pre-computed semantic element kinds derived from selector parts. */
+    elementKinds: Set<RuleElementKind>;
+}
+/**
+ * Semantic element classification for rules, derived from selector parts.
+ * Used by policy rules to determine applicable thresholds.
+ */
+type RuleElementKind = "heading" | "button" | "input" | "caption" | "paragraph" | "inline-formatting" | "pseudo-element";
+
+/**
+ * CSS Selector Types
+ */
+
+/**
+ * Combinator types between selector parts.
+ */
+type CombinatorType = "descendant" | "child" | "adjacent" | "sibling";
+/**
+ * A part of a compound selector.
+ */
+interface SelectorPart {
+    readonly type: "element" | "id" | "class" | "attribute" | "pseudo-class" | "pseudo-element" | "universal" | "nesting";
+    readonly value: string;
+    readonly raw: string;
+}
+interface SelectorAttributeConstraint {
+    name: string;
+    operator: "exists" | "equals" | "includes-word" | "dash-prefix" | "prefix" | "suffix" | "contains";
+    value: string | null;
+    caseInsensitive: boolean;
+}
+interface SelectorAnchor {
+    subjectTag: string | null;
+    classes: readonly string[];
+    attributes: readonly SelectorAttributeConstraint[];
+    includesDescendantCombinator: boolean;
+    includesPseudoSelector: boolean;
+    dynamic: boolean;
+    targetsCheckbox: boolean;
+    targetsTableCell: boolean;
+}
+/**
+ * Selector complexity metrics for analysis.
+ */
+interface SelectorComplexity {
+    depth: number;
+    breadth: number;
+    _flags: number;
+    pseudoClasses: string[];
+    pseudoElements: string[];
+    combinators: CombinatorType[];
+}
+/**
+ * Represents an individual selector within a rule.
+ */
+interface SelectorEntity {
+    id: number;
+    raw: string;
+    rule: RuleEntity;
+    specificity: Specificity;
+    specificityScore: number;
+    complexity: SelectorComplexity;
+    parts: SelectorPart[];
+    anchor: SelectorAnchor;
+    overrides: SelectorEntity[];
+    overriddenBy: SelectorEntity[];
+}
+
+/**
+ * SCSS-Specific Types
+ */
+
+/**
+ * Mixin parameter definition.
+ */
+interface MixinParameter {
+    name: string;
+    defaultValue: string | null;
+    isRest: boolean;
+}
+/**
+ * Mixin argument in @include.
+ */
+interface MixinArgument {
+    name: string | null;
+    value: string;
+    isNamed: boolean;
+}
+/**
+ * Function parameter definition.
+ */
+interface FunctionParameter {
+    name: string;
+    defaultValue: string | null;
+}
+/**
+ * @return statement in SCSS function.
+ */
+interface ReturnStatement {
+    node: AtRule;
+    value: string;
+}
+/**
+ * Represents an SCSS mixin definition.
+ */
+interface MixinEntity {
+    id: number;
+    name: string;
+    node: AtRule;
+    file: FileEntity;
+    parameters: MixinParameter[];
+    _flags: number;
+    declarations: DeclarationEntity[];
+    rules: RuleEntity[];
+    includes: MixinIncludeEntity[];
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Represents an SCSS @include directive.
+ */
+interface MixinIncludeEntity {
+    id: number;
+    name: string;
+    node: AtRule;
+    file: FileEntity;
+    arguments: MixinArgument[];
+    _flags: number;
+    resolvedMixin: MixinEntity | null;
+    rule: RuleEntity | null;
+    atRule: AtRuleEntity | null;
+}
+/**
+ * Represents an SCSS function definition.
+ */
+interface SCSSFunctionEntity {
+    id: number;
+    name: string;
+    node: AtRule;
+    file: FileEntity;
+    parameters: FunctionParameter[];
+    returnStatements: ReturnStatement[];
+    calls: FunctionCallEntity[];
+    _flags: number;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Represents an SCSS function call within a value.
+ */
+interface FunctionCallEntity {
+    id: number;
+    name: string;
+    declaration: DeclarationEntity;
+    file: FileEntity;
+    arguments: string[];
+    resolvedFunction: SCSSFunctionEntity | null;
+    _flags: number;
+    sourceIndex: number;
+}
+/**
+ * Represents an SCSS placeholder selector (%placeholder).
+ */
+interface PlaceholderEntity {
+    id: number;
+    name: string;
+    node: Rule;
+    file: FileEntity;
+    declarations: DeclarationEntity[];
+    extends: ExtendEntity[];
+    _flags: number;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Represents an SCSS @extend directive.
+ */
+interface ExtendEntity {
+    id: number;
+    selector: string;
+    node: AtRule;
+    file: FileEntity;
+    rule: RuleEntity;
+    resolvedPlaceholder: PlaceholderEntity | null;
+    resolvedRule: RuleEntity | null;
+    _flags: number;
+}
+
+/**
+ * CSS Parse Error
+ */
+/**
+ * CSS parse error with location information.
+ */
+interface CSSParseError {
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+    readonly endLine: number | null;
+    readonly endColumn: number | null;
+    readonly file: string;
+    readonly severity: "error" | "warn";
+    readonly source: string | null;
+    readonly isRecoverable: boolean;
+}
+
+/**
+ * CSSGraphImpl - CSS Program Graph Implementation
+ *
+ */
+
+/**
+ * A declaration referencing a keyframe name that has no matching @keyframes.
+ */
+interface UnresolvedAnimationRef {
+    readonly declaration: DeclarationEntity;
+    readonly name: string;
+}
+interface KeyframeLayoutMutation {
+    readonly property: string;
+    readonly values: readonly string[];
+    readonly declarations: readonly DeclarationEntity[];
+}
+interface FontFaceDescriptor {
+    readonly fontFace: AtRuleEntity;
+    readonly family: string;
+    readonly displayDeclaration: DeclarationEntity | null;
+    readonly srcDeclaration: DeclarationEntity | null;
+    readonly display: string | null;
+    readonly src: string | null;
+    readonly hasWebFontSource: boolean;
+    readonly hasEffectiveMetricOverrides: boolean;
+}
+declare class CSSGraph {
+    readonly kind: "css";
+    readonly options: CSSOptions;
+    readonly interner: StringInterner;
+    readonly logger: Logger;
+    sourceOrder: number;
+    hasScssFiles: boolean;
+    readonly files: FileEntity[];
+    readonly rules: RuleEntity[];
+    readonly selectors: SelectorEntity[];
+    readonly declarations: DeclarationEntity[];
+    readonly variables: VariableEntity[];
+    readonly variableRefs: VariableReferenceEntity[];
+    readonly atRules: AtRuleEntity[];
+    readonly tokens: ThemeTokenEntity[];
+    readonly mixins: MixinEntity[];
+    readonly includes: MixinIncludeEntity[];
+    readonly functions: SCSSFunctionEntity[];
+    readonly functionCalls: FunctionCallEntity[];
+    readonly placeholders: PlaceholderEntity[];
+    readonly extends: ExtendEntity[];
+    readonly filesByPath: Map<string, FileEntity>;
+    readonly variablesByName: Map<string, VariableEntity[]>;
+    readonly rulesBySelector: Map<string, RuleEntity[]>;
+    /** @internal Dedup index keyed by file+parent+selector+media+layer for duplicate detection. */
+    readonly _selectorDedupIndex: Map<string, RuleEntity[]>;
+    readonly mixinsByName: Map<string, MixinEntity>;
+    readonly functionsByName: Map<string, SCSSFunctionEntity>;
+    readonly placeholdersByName: Map<string, PlaceholderEntity>;
+    readonly layerOrder: Map<string, number>;
+    readonly declarationsByProperty: Map<string, DeclarationEntity[]>;
+    readonly atRulesByName: Map<string, AtRuleEntity[]>;
+    readonly atRulesByKind: Map<AtRuleKind, AtRuleEntity[]>;
+    readonly atRulesByNode: Map<AtRule, AtRuleEntity>;
+    readonly rulesByNode: Map<Rule, RuleEntity>;
+    readonly duplicateSelectors: Map<string, {
+        selector: string;
+        rules: RuleEntity[];
+    }>;
+    readonly tokensByCategory: Map<TokenCategory, ThemeTokenEntity[]>;
+    readonly importantDeclarations: DeclarationEntity[];
+    readonly globalVariables: VariableEntity[];
+    readonly unusedVariables: VariableEntity[];
+    readonly scssVariables: VariableEntity[];
+    readonly cssCustomProperties: VariableEntity[];
+    readonly unresolvedRefs: VariableReferenceEntity[];
+    readonly mediaQueries: AtRuleEntity[];
+    readonly keyframes: AtRuleEntity[];
+    readonly layers: AtRuleEntity[];
+    readonly fontFaces: AtRuleEntity[];
+    readonly supportsRules: AtRuleEntity[];
+    readonly unusedKeyframes: AtRuleEntity[];
+    readonly unusedMixins: MixinEntity[];
+    readonly unresolvedMixinIncludes: MixinIncludeEntity[];
+    readonly unusedFunctions: SCSSFunctionEntity[];
+    readonly unusedPlaceholders: PlaceholderEntity[];
+    readonly unresolvedExtends: ExtendEntity[];
+    readonly parseErrors: CSSParseError[];
+    readonly failedFilePaths: string[];
+    readonly tokenCategories: TokenCategory[];
+    readonly filesWithLayers: Set<string>;
+    readonly selectorsByPseudoClass: Map<string, SelectorEntity[]>;
+    readonly knownKeyframeNames: Set<string>;
+    readonly unresolvedAnimationRefs: UnresolvedAnimationRef[];
+    readonly declaredContainerNames: Map<string, DeclarationEntity[]>;
+    readonly containerQueryNames: Map<string, AtRuleEntity[]>;
+    readonly unusedContainerNames: Map<string, DeclarationEntity[]>;
+    readonly unknownContainerQueries: AtRuleEntity[];
+    /** Properties with 2+ declarations, each value pre-sorted by sourceOrder. */
+    readonly multiDeclarationProperties: Map<string, readonly DeclarationEntity[]>;
+    /** Declarations whose parent rule is inside a @keyframes block. */
+    readonly keyframeDeclarations: DeclarationEntity[];
+    /** Rules with zero declarations and zero nested rules. */
+    readonly emptyRules: RuleEntity[];
+    /** @keyframes at-rules with no effective keyframe declarations. */
+    readonly emptyKeyframes: AtRuleEntity[];
+    readonly colorDeclarations: DeclarationEntity[];
+    readonly calcDeclarations: DeclarationEntity[];
+    readonly varDeclarations: DeclarationEntity[];
+    readonly urlDeclarations: DeclarationEntity[];
+    readonly vendorPrefixedDeclarations: DeclarationEntity[];
+    readonly hardcodedColorDeclarations: DeclarationEntity[];
+    readonly overqualifiedSelectors: SelectorEntity[];
+    readonly idSelectors: SelectorEntity[];
+    readonly attributeSelectors: SelectorEntity[];
+    readonly universalSelectors: SelectorEntity[];
+    readonly classNameIndex: Map<string, SelectorEntity[]>;
+    readonly selectorsBySubjectTag: Map<string, SelectorEntity[]>;
+    readonly selectorsWithoutSubjectTag: SelectorEntity[];
+    readonly selectorsTargetingCheckbox: SelectorEntity[];
+    readonly selectorsTargetingTableCell: SelectorEntity[];
+    readonly layoutPropertiesByClassToken: Map<string, readonly string[]>;
+    readonly keyframeLayoutMutationsByName: Map<string, readonly KeyframeLayoutMutation[]>;
+    readonly fontFaceDescriptorsByFamily: Map<string, readonly FontFaceDescriptor[]>;
+    readonly usedFontFamiliesByRule: Map<number, readonly string[]>;
+    readonly usedFontFamilies: Set<string>;
+    /** Tailwind validator for utility class lookup (null if not a Tailwind project). */
+    readonly tailwind: TailwindValidator | null;
+    readonly deepNestedRules: RuleEntity[];
+    constructor(input: CSSInput);
+    intern(s: string): string;
+    nextFileId(): number;
+    nextRuleId(): number;
+    nextSelectorId(): number;
+    nextDeclarationId(): number;
+    nextVariableId(): number;
+    nextVariableRefId(): number;
+    nextAtRuleId(): number;
+    nextTokenId(): number;
+    nextMixinId(): number;
+    nextIncludeId(): number;
+    nextFunctionId(): number;
+    nextFunctionCallId(): number;
+    nextPlaceholderId(): number;
+    nextExtendId(): number;
+    nextSourceOrder(): number;
+    addFile(file: FileEntity): void;
+    addRule(rule: RuleEntity): void;
+    addSelector(selector: SelectorEntity): void;
+    addDeclaration(decl: DeclarationEntity): void;
+    addVariable(variable: VariableEntity): void;
+    addVariableRef(ref: VariableReferenceEntity): void;
+    addAtRule(atRule: AtRuleEntity): void;
+    addToken(token: ThemeTokenEntity): void;
+    addMixin(mixin: MixinEntity): void;
+    addMixinInclude(include: MixinIncludeEntity): void;
+    addFunction(fn: SCSSFunctionEntity): void;
+    addFunctionCall(call: FunctionCallEntity): void;
+    addPlaceholder(placeholder: PlaceholderEntity): void;
+    addExtend(ext: ExtendEntity): void;
+    addParseError(error: CSSParseError): void;
+    addFailedFile(path: string): void;
+    registerRuleBySelector(selector: string, rule: RuleEntity): void;
+    registerLayerOrder(name: string, order: number): void;
+    /**
+     * Retrieve declarations matching any of the given property names.
+     * Uses the pre-built declarationsByProperty index for O(k) lookups.
+     */
+    declarationsForProperties(...properties: string[]): readonly DeclarationEntity[];
+    /**
+     * Build derived indexes that require all entities to be populated.
+     * Called after all phases complete.
+     */
+    buildDerivedIndexes(): void;
+    private buildRuleDeclarationIndexes;
+    private buildContainingMediaStacks;
+    private buildKeyframeIndex;
+    private buildContainerNameIndexes;
+    private buildElementKinds;
+    private buildFilesWithLayers;
+    private buildSelectorPseudoClassIndex;
+    /**
+     * Sort each declarationsByProperty list by sourceOrder and populate
+     * multiDeclarationProperties with only those having 2+ entries.
+     */
+    private buildMultiDeclarationProperties;
+    /**
+     * Collect declarations whose parent rule is inside a @keyframes block.
+     */
+    private buildKeyframeDeclarations;
+    private buildKeyframeLayoutMutationsByName;
+    /**
+     * Collect rules with no declarations and no nested rules.
+     */
+    private buildEmptyRules;
+    /**
+     * Collect @keyframes with no effective keyframe declarations.
+     */
+    private buildEmptyKeyframes;
+    private buildDeclarationDerivedIndexes;
+    private buildSelectorDerivedIndexes;
+    private buildLayoutPropertiesByClassToken;
+    private buildFontFamilyUsageByRule;
+    private buildFontFaceDescriptorsByFamily;
+    private buildRuleDerivedIndexes;
+    buildUnusedIndexes(): void;
+}
+
+interface LayoutPerfStatsMutable {
+    elementsScanned: number;
+    selectorCandidatesChecked: number;
+    compiledSelectorCount: number;
+    selectorsRejectedUnsupported: number;
+    selectorsGuardedConditional: number;
+    ancestryChecks: number;
+    matchEdgesCreated: number;
+    casesScored: number;
+    casesCollected: number;
+    casesRejectedLowEvidence: number;
+    casesRejectedThreshold: number;
+    casesRejectedUndecidable: number;
+    casesRejectedIdentifiability: number;
+    undecidableInterval: number;
+    conditionalSignals: number;
+    totalSignals: number;
+    cohortUnimodalFalse: number;
+    factorCoverageSum: number;
+    factorCoverageCount: number;
+    posteriorWidths: number[];
+    uncertaintyEscalations: number;
+    signalSnapshotsBuilt: number;
+    signalSnapshotCacheHits: number;
+    measurementIndexHits: number;
+    contextsClassified: number;
+    diagnosticsEmitted: number;
+    selectorIndexMs: number;
+    selectorMatchMs: number;
+    cascadeBuildMs: number;
+    caseBuildMs: number;
+    scoringMs: number;
+    elapsedMs: number;
+}
+
+type LayoutAxisModel = "horizontal-tb" | "vertical-rl" | "vertical-lr";
+type InlineDirectionModel = "ltr" | "rtl";
+type AlignmentContextKind = "inline-formatting" | "table-cell" | "flex-cross-axis" | "grid-cross-axis" | "block-flow" | "positioned-offset";
+type LayoutContextContainerKind = "table" | "flex" | "grid" | "inline" | "block";
+type ContextCertainty = "resolved" | "conditional" | "unknown";
+interface LayoutContextEvidence {
+    readonly containerKind: LayoutContextContainerKind;
+    readonly containerKindCertainty: ContextCertainty;
+    readonly hasTableSemantics: boolean;
+    readonly hasPositionedOffset: boolean;
+    readonly positionedOffsetCertainty: ContextCertainty;
+}
+interface AlignmentContext {
+    readonly kind: AlignmentContextKind;
+    readonly certainty: ContextCertainty;
+    readonly parentSolidFile: string;
+    readonly parentElementId: number;
+    readonly parentElementKey: string;
+    readonly parentTag: string | null;
+    readonly axis: LayoutAxisModel;
+    readonly axisCertainty: ContextCertainty;
+    readonly inlineDirection: InlineDirectionModel;
+    readonly inlineDirectionCertainty: ContextCertainty;
+    readonly parentDisplay: string | null;
+    readonly parentAlignItems: string | null;
+    readonly parentPlaceItems: string | null;
+    readonly hasPositionedOffset: boolean;
+    readonly evidence: LayoutContextEvidence;
+}
+
+type LayoutGuardConditionKind = "media" | "supports" | "container";
+interface LayoutGuardConditionProvenance {
+    readonly kind: LayoutGuardConditionKind;
+    readonly query: string | null;
+    readonly key: string;
+}
+
+declare const layoutSignalNames: readonly ["line-height", "font-size", "width", "inline-size", "height", "block-size", "min-width", "min-block-size", "min-height", "aspect-ratio", "vertical-align", "display", "white-space", "object-fit", "overflow", "overflow-y", "overflow-anchor", "scrollbar-gutter", "scrollbar-width", "contain-intrinsic-size", "content-visibility", "align-items", "align-self", "justify-items", "place-items", "place-self", "appearance", "box-sizing", "padding-top", "padding-left", "padding-right", "padding-bottom", "border-top-width", "border-left-width", "border-right-width", "border-bottom-width", "position", "top", "bottom", "margin-top", "margin-bottom", "transform", "translate", "inset-block-start", "inset-block-end", "writing-mode", "direction"];
+type LayoutSignalName = (typeof layoutSignalNames)[number];
+type LayoutSignalSource = "selector" | "inline-style";
+type LayoutSignalGuard = "unconditional" | "conditional";
+interface LayoutGuardProvenance {
+    readonly kind: LayoutSignalGuard;
+    readonly conditions: readonly LayoutGuardConditionProvenance[];
+    readonly key: string;
+}
+type LayoutSignalUnit = "px" | "unitless" | "keyword" | "unknown";
+interface LayoutKnownSignalValue {
+    readonly kind: "known";
+    readonly name: LayoutSignalName;
+    readonly raw: string;
+    readonly normalized: string;
+    readonly source: LayoutSignalSource;
+    readonly guard: LayoutSignalGuard;
+    readonly guardProvenance: LayoutGuardProvenance;
+    readonly unit: LayoutSignalUnit;
+    readonly px: number | null;
+    readonly quality: "exact" | "estimated";
+}
+interface LayoutUnknownSignalValue {
+    readonly kind: "unknown";
+    readonly name: LayoutSignalName;
+    readonly raw: string | null;
+    readonly source: LayoutSignalSource | null;
+    readonly guard: LayoutSignalGuard;
+    readonly guardProvenance: LayoutGuardProvenance;
+    readonly reason: string;
+}
+type LayoutSignalValue = LayoutKnownSignalValue | LayoutUnknownSignalValue;
+type LayoutTextualContentState = "yes" | "no" | "unknown" | "dynamic-text";
+interface LayoutSignalSnapshot {
+    readonly solidFile: string;
+    readonly elementId: number;
+    readonly elementKey: string;
+    readonly tag: string | null;
+    readonly textualContent: LayoutTextualContentState;
+    readonly isControl: boolean;
+    readonly isReplaced: boolean;
+    readonly signals: ReadonlyMap<LayoutSignalName, LayoutSignalValue>;
+    readonly knownSignalCount: number;
+    readonly unknownSignalCount: number;
+    readonly conditionalSignalCount: number;
+}
+interface AlignmentElementEvidence {
+    readonly solidFile: string;
+    readonly elementKey: string;
+    readonly elementId: number;
+    readonly tag: string | null;
+    readonly snapshot: LayoutSignalSnapshot;
+}
+type AlignmentTextContrast = "different" | "same" | "unknown";
+type SignalConflictValue = "conflict" | "aligned" | "unknown";
+interface SignalConflictEvidence {
+    readonly value: SignalConflictValue;
+    readonly kind: EvidenceValueKind;
+}
+interface AlignmentCohortSignals {
+    readonly verticalAlign: SignalConflictEvidence;
+    readonly alignSelf: SignalConflictEvidence;
+    readonly placeSelf: SignalConflictEvidence;
+    readonly hasControlOrReplacedPeer: boolean;
+    readonly textContrastWithPeers: AlignmentTextContrast;
+}
+type CohortSubjectMembership = "dominant" | "nondominant" | "ambiguous" | "insufficient";
+interface CohortIdentifiability {
+    readonly dominantShare: number;
+    readonly subjectExcludedDominantShare: number;
+    readonly subjectMembership: CohortSubjectMembership;
+    readonly ambiguous: boolean;
+    readonly kind: EvidenceValueKind;
+}
+interface AlignmentCohortProfile {
+    readonly medianDeclaredOffsetPx: number | null;
+    readonly declaredOffsetDispersionPx: number | null;
+    readonly medianEffectiveOffsetPx: number | null;
+    readonly effectiveOffsetDispersionPx: number | null;
+    readonly medianLineHeightPx: number | null;
+    readonly lineHeightDispersionPx: number | null;
+    readonly dominantClusterSize: number;
+    readonly dominantClusterShare: number;
+    readonly unimodal: boolean;
+}
+interface AlignmentCohortFactSummary {
+    readonly exact: number;
+    readonly interval: number;
+    readonly unknown: number;
+    readonly conditional: number;
+    readonly total: number;
+    readonly exactShare: number;
+    readonly intervalShare: number;
+    readonly unknownShare: number;
+    readonly conditionalShare: number;
+}
+interface HotEvidenceWitness<T> extends EvidenceWitness<T> {
+    readonly present: boolean;
+}
+type HotNumericSignalEvidence = HotEvidenceWitness<number>;
+type HotNormalizedSignalEvidence = HotEvidenceWitness<string>;
+interface LayoutSnapshotHotSignals {
+    readonly lineHeight: HotNumericSignalEvidence;
+    readonly verticalAlign: HotNormalizedSignalEvidence;
+    readonly alignSelf: HotNormalizedSignalEvidence;
+    readonly placeSelf: HotNormalizedSignalEvidence;
+    readonly writingMode: HotNormalizedSignalEvidence;
+    readonly direction: HotNormalizedSignalEvidence;
+    readonly display: HotNormalizedSignalEvidence;
+    readonly alignItems: HotNormalizedSignalEvidence;
+    readonly placeItems: HotNormalizedSignalEvidence;
+    readonly position: HotNormalizedSignalEvidence;
+    readonly insetBlockStart: HotNumericSignalEvidence;
+    readonly insetBlockEnd: HotNumericSignalEvidence;
+    readonly transform: HotNumericSignalEvidence;
+    readonly translate: HotNumericSignalEvidence;
+    readonly top: HotNumericSignalEvidence;
+    readonly bottom: HotNumericSignalEvidence;
+    readonly marginTop: HotNumericSignalEvidence;
+    readonly marginBottom: HotNumericSignalEvidence;
+}
+interface LayoutCohortSubjectStats {
+    readonly element: AlignmentElementEvidence;
+    readonly declaredOffset: NumericEvidenceValue;
+    readonly effectiveOffset: NumericEvidenceValue;
+    readonly lineHeight: NumericEvidenceValue;
+    readonly baselineProfile: AlignmentCohortProfile;
+    readonly signals: AlignmentCohortSignals;
+    readonly identifiability: CohortIdentifiability;
+    readonly contentComposition: ContentCompositionFingerprint;
+}
+interface LayoutCohortStats {
+    readonly profile: AlignmentCohortProfile;
+    readonly snapshots: readonly LayoutSignalSnapshot[];
+    readonly factSummary: AlignmentCohortFactSummary;
+    readonly provenance: EvidenceProvenance;
+    readonly conditionalSignalCount: number;
+    readonly totalSignalCount: number;
+    readonly subjectsByElementKey: ReadonlyMap<string, LayoutCohortSubjectStats>;
+    /** Element keys excluded from cohort analysis (e.g. visually-hidden accessible elements). */
+    readonly excludedElementKeys: ReadonlySet<string>;
+}
+type ContentCompositionClassification = "text-only" | "replaced-only" | "mixed-unmitigated" | "mixed-mitigated" | "block-segmented" | "unknown";
+/**
+ * Distinguishes intrinsically-replaced elements (img, svg, video, canvas) from
+ * inline-block/inline-flex containers. Their baseline rules differ: an img uses
+ * its bottom edge as the baseline, while an inline-block uses its last line of text.
+ */
+type InlineReplacedKind = "intrinsic" | "container";
+interface ContentCompositionFingerprint {
+    readonly hasTextContent: boolean;
+    readonly hasInlineReplaced: boolean;
+    readonly inlineReplacedKind: InlineReplacedKind | null;
+    readonly hasHeightContributingDescendant: boolean;
+    readonly wrappingContextMitigates: boolean;
+    readonly hasVerticalAlignMitigation: boolean;
+    readonly mixedContentDepth: number;
+    readonly classification: ContentCompositionClassification;
+    readonly analyzableChildCount: number;
+    readonly totalChildCount: number;
+    readonly hasOnlyBlockChildren: boolean;
+}
+type EvidenceValueKind = "exact" | "interval" | "conditional" | "unknown";
+interface EvidenceWitness<T> {
+    readonly value: T | null;
+    readonly kind: EvidenceValueKind;
+}
+type NumericEvidenceValue = EvidenceWitness<number>;
+interface EvidenceProvenance {
+    readonly reason: string;
+    readonly guardKey: string;
+    readonly guards: readonly LayoutGuardConditionProvenance[];
+}
+
+interface LayoutCascadedDeclaration {
+    readonly value: string;
+    readonly source: "selector" | "inline-style";
+    readonly guard: LayoutSignalGuard;
+    readonly guardProvenance: LayoutGuardProvenance;
+}
+interface LayoutElementNode {
+    readonly key: string;
+    readonly solidFile: string;
+    readonly elementId: number;
+    readonly tag: string | null;
+    readonly tagName: string | null;
+    readonly classTokens: readonly string[];
+    readonly classTokenSet: ReadonlySet<string>;
+    readonly inlineStyleKeys: readonly string[];
+    readonly parentElementId: number | null;
+    readonly parentElementKey: string | null;
+    readonly parentElementNode: LayoutElementNode | null;
+    readonly previousSiblingNode: LayoutElementNode | null;
+    readonly siblingIndex: number;
+    readonly siblingCount: number;
+    readonly siblingTypeIndex: number;
+    readonly siblingTypeCount: number;
+    readonly selectorDispatchKeys: readonly string[];
+    readonly attributes: ReadonlyMap<string, string | null>;
+    readonly inlineStyleValues: ReadonlyMap<string, string>;
+    readonly textualContent: "yes" | "no" | "unknown" | "dynamic-text";
+    readonly isControl: boolean;
+    readonly isReplaced: boolean;
+}
+interface LayoutStyleRuleNode {
+    readonly cssFile: string;
+    readonly ruleId: number;
+    readonly selectorId: number;
+}
+interface LayoutMatchEdge {
+    readonly solidFile: string;
+    readonly elementId: number;
+    readonly elementKey: string;
+    readonly selectorId: number;
+    readonly specificityScore: number;
+    readonly sourceOrder: number;
+}
+interface LayoutElementRef {
+    readonly solid: SolidGraph;
+    readonly element: JSXElementEntity;
+}
+type LayoutReservedSpaceReason = "height" | "block-size" | "min-height" | "min-block-size" | "contain-intrinsic-size" | "aspect-ratio+width" | "aspect-ratio+inline-size" | "aspect-ratio+min-width" | "aspect-ratio+min-block-size" | "aspect-ratio+min-height";
+interface LayoutReservedSpaceFact {
+    readonly hasReservedSpace: boolean;
+    readonly reasons: readonly LayoutReservedSpaceReason[];
+    readonly hasUsableInlineDimension: boolean;
+    readonly hasUsableBlockDimension: boolean;
+    readonly hasContainIntrinsicSize: boolean;
+    readonly hasUsableAspectRatio: boolean;
+}
+type LayoutScrollAxis = "x" | "y" | "both" | "none";
+interface LayoutScrollContainerFact {
+    readonly isScrollContainer: boolean;
+    readonly axis: LayoutScrollAxis;
+    readonly overflow: string | null;
+    readonly overflowY: string | null;
+    readonly hasConditionalScroll: boolean;
+    readonly hasUnconditionalScroll: boolean;
+}
+interface LayoutFlowParticipationFact {
+    readonly inFlow: boolean;
+    readonly position: string | null;
+    readonly hasConditionalOutOfFlow: boolean;
+    readonly hasUnconditionalOutOfFlow: boolean;
+}
+interface LayoutContainingBlockFact {
+    readonly nearestPositionedAncestorKey: string | null;
+    readonly nearestPositionedAncestorHasReservedSpace: boolean;
+}
+interface LayoutConditionalSignalDeltaFact {
+    readonly hasConditional: boolean;
+    readonly hasDelta: boolean;
+    readonly conditionalValues: readonly string[];
+    readonly unconditionalValues: readonly string[];
+    readonly hasConditionalScrollValue: boolean;
+    readonly hasConditionalNonScrollValue: boolean;
+    readonly hasUnconditionalScrollValue: boolean;
+    readonly hasUnconditionalNonScrollValue: boolean;
+}
+interface LayoutStatefulSelectorEntry {
+    readonly raw: string;
+    readonly isStateful: boolean;
+    /** Pseudo-classes from STATE_PSEUDO_SET that caused this selector to be classified as stateful. */
+    readonly statePseudoClasses: readonly string[];
+    /**
+     * True when ALL state pseudo-classes are "direct" interaction (hover, focus, active, etc.),
+     * meaning state changes only from the user physically interacting with the element itself.
+     * False when any pseudo-class is "indirect" (checked, target) — state can change externally.
+     */
+    readonly isDirectInteraction: boolean;
+    readonly baseLookupKeys: readonly string[];
+}
+interface LayoutNormalizedRuleDeclaration {
+    readonly declarationId: number;
+    readonly property: string;
+    readonly normalizedValue: string;
+    readonly filePath: string;
+    readonly startLine: number;
+    readonly startColumn: number;
+    readonly propertyLength: number;
+}
+interface LayoutGraphTopology {
+    readonly elements: readonly LayoutElementNode[];
+    readonly childrenByParentNode: ReadonlyMap<LayoutElementNode, readonly LayoutElementNode[]>;
+    readonly elementBySolidFileAndId: ReadonlyMap<string, ReadonlyMap<number, LayoutElementNode>>;
+    readonly elementRefsBySolidFileAndId: ReadonlyMap<string, ReadonlyMap<number, LayoutElementRef>>;
+    readonly elementsByTagName: ReadonlyMap<string, readonly LayoutElementNode[]>;
+    readonly measurementNodeByRootKey: ReadonlyMap<string, LayoutElementNode>;
+}
+interface LayoutGraphCascade {
+    readonly styleRules: readonly LayoutStyleRuleNode[];
+    readonly applies: readonly LayoutMatchEdge[];
+    readonly cssScopeBySolidFile: ReadonlyMap<string, readonly string[]>;
+    readonly appliesByElementKey: ReadonlyMap<string, readonly LayoutMatchEdge[]>;
+    readonly selectorCandidatesByElementKey: ReadonlyMap<string, readonly number[]>;
+    readonly selectorsById: ReadonlyMap<number, SelectorEntity>;
+    readonly cascadeByElementNode: WeakMap<LayoutElementNode, ReadonlyMap<string, LayoutCascadedDeclaration>>;
+    readonly snapshotByElementNode: WeakMap<LayoutElementNode, LayoutSignalSnapshot>;
+    readonly snapshotHotSignalsByElementKey: ReadonlyMap<string, LayoutSnapshotHotSignals>;
+}
+interface LayoutGraphFacts {
+    readonly reservedSpaceFactsByElementKey: ReadonlyMap<string, LayoutReservedSpaceFact>;
+    readonly scrollContainerFactsByElementKey: ReadonlyMap<string, LayoutScrollContainerFact>;
+    readonly flowParticipationFactsByElementKey: ReadonlyMap<string, LayoutFlowParticipationFact>;
+    readonly containingBlockFactsByElementKey: ReadonlyMap<string, LayoutContainingBlockFact>;
+    readonly conditionalSignalDeltaFactsByElementKey: ReadonlyMap<string, ReadonlyMap<LayoutSignalName, LayoutConditionalSignalDeltaFact>>;
+    readonly baselineOffsetFactsByElementKey: ReadonlyMap<string, ReadonlyMap<LayoutSignalName, readonly number[]>>;
+}
+interface LayoutGraphCohorts {
+    readonly cohortStatsByParentNode: ReadonlyMap<LayoutElementNode, LayoutCohortStats>;
+    readonly contextByParentNode: ReadonlyMap<LayoutElementNode, AlignmentContext>;
+}
+interface LayoutGraphIndexes {
+    readonly elementsWithConditionalDeltaBySignal: ReadonlyMap<LayoutSignalName, readonly LayoutElementNode[]>;
+    readonly elementsWithConditionalOverflowDelta: readonly LayoutElementNode[];
+    readonly elementsWithConditionalOffsetDelta: readonly LayoutElementNode[];
+    readonly elementsByKnownSignalValue: ReadonlyMap<LayoutSignalName, ReadonlyMap<string, readonly LayoutElementNode[]>>;
+    readonly dynamicSlotCandidateElements: readonly LayoutElementNode[];
+    readonly scrollContainerElements: readonly LayoutElementNode[];
+    readonly statefulSelectorEntriesByRuleId: ReadonlyMap<number, readonly LayoutStatefulSelectorEntry[]>;
+    readonly statefulNormalizedDeclarationsByRuleId: ReadonlyMap<number, readonly LayoutNormalizedRuleDeclaration[]>;
+    readonly statefulBaseValueIndex: ReadonlyMap<string, ReadonlyMap<string, ReadonlySet<string>>>;
+}
+interface LayoutGraph extends LayoutGraphTopology, LayoutGraphCascade, LayoutGraphFacts, LayoutGraphCohorts, LayoutGraphIndexes {
+    readonly perf: LayoutPerfStatsMutable;
+}
+
+/**
+ * Versioned cache for SolidGraph, CSSGraph, and LayoutGraph instances.
+ *
+ * SolidGraphs are cached per file path with a version string.
+ * The CSSGraph is a single instance covering all CSS files,
+ * invalidated via a monotonic generation counter bumped by
+ * `invalidate()` or `invalidateAll()`.
+ */
+declare class GraphCache {
+    private readonly log;
+    private readonly solids;
+    private readonly crossFileDiagnostics;
+    private crossFileResults;
+    private css;
+    private solidGeneration;
+    private cssGeneration;
+    private layout;
+    constructor(log?: Logger);
+    /**
+     * Check if a SolidGraph is cached and current for a file path.
+     *
+     * Allows callers to skip builder allocation when the cache is warm.
+     *
+     * @param path Absolute file path
+     * @param version Script version string from the TS project service
+     */
+    hasSolidGraph(path: string, version: string): boolean;
+    /**
+     * Store a pre-built SolidGraph in the cache.
+     *
+     * Used by the CLI lint command which builds graphs during single-file
+     * analysis and pre-populates the cache for cross-file reuse.
+     *
+     * @param path Absolute file path
+     * @param version Script version string from the TS project service
+     * @param graph Pre-built SolidGraph
+     */
+    setSolidGraph(path: string, version: string, graph: SolidGraph): void;
+    /**
+     * Get or build a SolidGraph for a file path.
+     *
+     * Returns the cached graph if the version matches.
+     * Otherwise invokes the builder, caches the result, and returns it.
+     *
+     * @param path Absolute file path
+     * @param version Script version string from the TS project service
+     * @param build Builder function invoked on cache miss
+     */
+    getSolidGraph(path: string, version: string, build: () => SolidGraph): SolidGraph;
+    /**
+     * Get the cached CSSGraph, or rebuild it.
+     *
+     * Returns the cached graph if the generation matches the current
+     * CSS generation counter. Otherwise invokes the builder, caches
+     * the result at the current generation, and returns it.
+     *
+     * @param build Builder function invoked on cache miss
+     */
+    getCSSGraph(build: () => CSSGraph): CSSGraph;
+    /**
+     * Get or build a LayoutGraph for current Solid/CSS cache state.
+     *
+     * Returns cached LayoutGraph when both Solid signature (path+version)
+     * and CSS generation match. Otherwise invokes the builder.
+     *
+     * @param build Builder function invoked on cache miss
+     */
+    getLayoutGraph(build: () => LayoutGraph): LayoutGraph;
+    /**
+     * Invalidate cached graphs affected by a file change.
+     *
+     * Classifies the path and invalidates the appropriate cache:
+     * solid files evict their per-file SolidGraph, CSS files bump
+     * the CSSGraph generation counter.
+     *
+     * @param path Absolute file path that changed
+     */
+    invalidate(path: string): void;
+    /**
+     * Invalidate all cached graphs.
+     *
+     * Called on workspace-level events like config changes.
+     */
+    invalidateAll(): void;
+    /**
+     * Get all cached SolidGraphs.
+     *
+     * Returns a snapshot array of all currently-cached graphs.
+     * Used by cross-file analysis which needs all SolidGraphs.
+     */
+    getAllSolidGraphs(): readonly SolidGraph[];
+    /**
+     * Get the cached CSSGraph, or null if not cached.
+     */
+    getCachedCSSGraph(): CSSGraph | null;
+    /**
+     * Get the cached LayoutGraph, or null if not cached.
+     */
+    getCachedLayoutGraph(): LayoutGraph | null;
+    /**
+     * Get cached cross-file diagnostics for a file path.
+     *
+     * Returns the previous cross-file results so single-file-only
+     * re-analysis (during typing) can merge them without re-running
+     * cross-file rules.
+     *
+     * @param path Absolute file path
+     */
+    getCachedCrossFileDiagnostics(path: string): readonly Diagnostic[];
+    /**
+     * Store cross-file diagnostics for a file path.
+     *
+     * @param path Absolute file path
+     * @param diagnostics Cross-file diagnostics for this path
+     */
+    setCachedCrossFileDiagnostics(path: string, diagnostics: readonly Diagnostic[]): void;
+    /**
+     * Get workspace-level cross-file results if the underlying graphs haven't changed.
+     *
+     * Returns the full per-file map when the solid signature and CSS generation
+     * match, meaning no graphs were rebuilt since the last run. Returns null
+     * when results are stale and `runCrossFileRules` must re-execute.
+     */
+    getCachedCrossFileResults(): ReadonlyMap<string, readonly Diagnostic[]> | null;
+    /**
+     * Store workspace-level cross-file results bucketed by file.
+     *
+     * Called after `runCrossFileRules` completes. Captures the current
+     * solid signature and CSS generation so subsequent lookups are O(1)
+     * until a graph changes.
+     *
+     * @param allDiagnostics All cross-file diagnostics from the workspace run
+     */
+    setCachedCrossFileResults(allDiagnostics: readonly Diagnostic[]): void;
+    /** Number of cached SolidGraphs. */
+    get solidCount(): number;
+    /** The logger instance used by this cache. */
+    get logger(): Logger;
+}
+
+/**
+ * Build a SolidGraph from input.
+ *
+ * Exported for use by cross-file rules that need to build graphs
+ * without running all solid rules.
+ */
+declare function buildSolidGraph(input: SolidInput): SolidGraph;
+/**
+ * Analyze pre-parsed input and emit diagnostics.
+ *
+ * For use by ESLint integration and LSP where the caller
+ * has already parsed the file (e.g. ESLint provides SourceCode).
+ */
+declare function analyzeInput(input: SolidInput, emit: Emit): void;
+/**
+ * Run single-file Solid rules on a pre-built graph.
+ *
+ * Separates rule execution from graph construction so callers that
+ * 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;
+/**
+ * The Solid.js plugin.
+ *
+ * Analyzes Solid.js files by reading from disk, parsing with
+ * @typescript-eslint/parser, 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;
+
+/**
+ * Build a CSSGraph from input.
+ *
+ * When `externalCustomProperties` is present in the input, generates a synthetic
+ * CSS file declaring those properties in `:root` and includes it in the graph.
+ * This ensures library-provided custom properties resolve through the normal
+ * cascade and resolution pipeline.
+ *
+ * Exported for use by cross-file rules that need to build graphs
+ * without running all CSS rules.
+ */
+declare function buildCSSGraph(input: CSSInput): CSSGraph;
+/**
+ * The CSS plugin.
+ *
+ * Analyzes CSS/SCSS files by reading from disk, building a CSSGraph,
+ * and running all rules. Rules push diagnostics via the emit callback.
+ *
+ * @example
+ * ```ts
+ * import { createRunner, CSSPlugin } from "@drskillissue/ganko"
+ *
+ * const runner = createRunner({ plugins: [CSSPlugin] })
+ * const diagnostics = runner.run(["src/styles/app.css"])
+ * ```
+ */
+declare const CSSPlugin: Plugin<"css">;
+
+/**
+ * Library Analysis — Extracts CSS custom properties provided by installed dependencies.
+ *
+ * Scans dependency packages for CSS custom property definitions injected at runtime
+ * via JavaScript (e.g., inline style attributes in JSX). This enables the resolution
+ * engine to treat library-provided properties as defined rather than flagging them
+ * as unresolved.
+ *
+ * Architecture:
+ * 1. Read project package.json files to discover direct dependencies
+ * 2. For each dependency, scan its dist/source files for CSS custom property patterns
+ * 3. Return discovered properties as a synthetic CSS `:root` declaration block
+ * 4. The caller feeds this into the normal CSS parsing pipeline as an additional file
+ *
+ * The scanner detects properties set via:
+ * - JSX style object keys: `"--kb-accordion-content-height": value`
+ * - style.setProperty calls: `style.setProperty("--kb-accordion-content-height", ...)`
+ * - CSS-in-JS template literals with custom property definitions
+ */
+/**
+ * Scan installed dependencies for CSS custom properties they inject at runtime.
+ *
+ * Reads each direct dependency's package.json to find its dist directory,
+ * then scans JavaScript/JSX files for CSS custom property name patterns.
+ *
+ * @param projectRoot - Absolute path to the project root (containing package.json)
+ * @returns Set of CSS custom property names (e.g., "--kb-accordion-content-height")
+ */
+declare function scanDependencyCustomProperties(projectRoot: string): ReadonlySet<string>;
+
+/**
+ * Accessibility Policy Templates
+ *
+ * Predefined bundles of sizing, spacing, and contrast constraints
+ * derived from WCAG 2.2, Material Design 3, Apple HIG, and
+ * W3C Low Vision Needs.
+ */
+
+/** Set the active policy for all policy rules. */
+declare function setActivePolicy(name: string): void;
+
+declare function buildLayoutGraph(solids: readonly SolidGraph[], css: CSSGraph, logger?: Logger): LayoutGraph;
+
+interface CrossRuleContext {
+    readonly solids: readonly SolidGraph[];
+    readonly css: CSSGraph;
+    readonly layout: LayoutGraph;
+}
+
+/**
+ * Run cross-file rules against pre-built graphs.
+ *
+ * Separates rule execution from graph construction so that callers
+ * with cached graphs (e.g. LSP GraphCache) can skip redundant parsing.
+ *
+ * @param context Pre-built Solid, CSS, and layout graphs
+ * @param emit Diagnostic emitter
+ */
+declare function runCrossFileRules(context: CrossRuleContext, emit: Emit, log?: Logger): 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 };