@drskillissue/ganko 0.2.82 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { RuleOverrides, Logger, StringInterner } from '@drskillissue/ganko-shared';
+import { RuleOverrides, Logger, StringInterner, WorkspaceLayout } from '@drskillissue/ganko-shared';
 import { Declaration, AtRule, Root, Rule } from 'postcss';
 export { RULES, RULES_BY_CATEGORY, RuleEntry, getRule } from './rules-manifest.js';
 
@@ -51,7 +51,7 @@ interface CommentEntry {
 }
 
 /** Emit callback type for pushing diagnostics */
-type Emit = (d: Diagnostic) => void;
+type Emit$1 = (d: Diagnostic) => void;
 /**
  * A plugin provides a graph type and its rules.
  *
@@ -64,7 +64,7 @@ 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, context?: {
+    analyze(files: readonly string[], emit: Emit$1, context?: {
         program: ts.Program;
     }): void;
 }
@@ -102,7 +102,7 @@ interface Runner {
  * @param overrides - Current rule override map
  * @returns Wrapped emit that suppresses/remaps per overrides
  */
-declare function createOverrideEmit(target: Emit, overrides: RuleOverrides): Emit;
+declare function createOverrideEmit(target: Emit$1, overrides: RuleOverrides): Emit$1;
 /**
  * Create a runner from configuration.
  */
@@ -194,12 +194,12 @@ declare class TypeResolver {
      *
      * Returns null if the type is not reactive.
      */
-    getReactiveKind(node: ts.Node): ReactiveKind | null;
+    getReactiveKind(node: ts.Node): ReactiveKind$1 | null;
     /**
      * Get both reactive kind AND type info in a single call.
      */
     getReactiveKindWithType(node: ts.Node): {
-        kind: ReactiveKind | null;
+        kind: ReactiveKind$1 | null;
         type: TypeInfo | null;
     };
     /**
@@ -340,7 +340,7 @@ interface VariableEntity$1 {
     reads: ReadEntity[];
     type: TypeInfo | null;
     isReactive: boolean;
-    reactiveKind: ReactiveKind | null;
+    reactiveKind: ReactiveKind$1 | null;
     isSignalLike: boolean;
     isMemoVariable: boolean;
     hasPropertyAssignment: boolean;
@@ -350,7 +350,7 @@ interface VariableEntity$1 {
  *
  * Different kinds have different behaviors and tracking rules.
  */
-type ReactiveKind = "signal" | "store" | "props" | "memo" | "derived" | "accessor" | "resource";
+type ReactiveKind$1 = "signal" | "store" | "props" | "memo" | "derived" | "accessor" | "resource";
 /** Assignment operator type extracted from AssignmentExpression */
 type AssignmentOperator = ts.SyntaxKind;
 /**
@@ -977,7 +977,7 @@ interface ExportEntity {
     /** Whether this is the default export */
     readonly isDefault: boolean;
     /** Reactive kind if this exports a reactive value */
-    readonly reactiveKind: ReactiveKind | null;
+    readonly reactiveKind: ReactiveKind$1 | null;
     /**
      * Signature string for change detection.
      * Used by workspace layer to detect export API changes.
@@ -1344,11 +1344,118 @@ interface OwnershipEdge {
     readonly child: ComputationEntity;
 }
 
+interface JSXAttributeWithElement$1 {
+    readonly attr: JSXAttributeEntity;
+    readonly element: JSXElementEntity;
+}
+interface JSXStaticClassIndex$1 {
+    readonly hasDynamicClass: boolean;
+    readonly tokens: readonly string[];
+}
+interface JSXStaticObjectKeyIndex$1 {
+    readonly hasDynamic: boolean;
+    readonly keys: readonly string[];
+}
+interface JSXObjectPropertyWithElement$1 {
+    readonly property: ts.ObjectLiteralElementLike;
+    readonly attr: JSXAttributeEntity;
+    readonly element: JSXElementEntity;
+}
+interface SolidSyntaxTree {
+    readonly kind: "solid";
+    readonly filePath: string;
+    readonly version: string;
+    readonly sourceFile: ts.SourceFile;
+    readonly comments: readonly CommentEntry[];
+    readonly scopes: readonly ScopeEntity[];
+    readonly variables: readonly VariableEntity$1[];
+    readonly functions: readonly FunctionEntity[];
+    readonly calls: readonly CallEntity[];
+    readonly jsxElements: readonly JSXElementEntity[];
+    readonly imports: readonly ImportEntity[];
+    readonly exports: readonly ExportEntity[];
+    readonly classes: readonly ClassEntity[];
+    readonly properties: readonly PropertyEntity[];
+    readonly propertyAssignments: readonly PropertyAssignmentEntity[];
+    readonly conditionalSpreads: readonly ConditionalSpreadEntity[];
+    readonly objectSpreads: readonly ObjectSpreadEntity[];
+    readonly nonNullAssertions: readonly NonNullAssertionEntity[];
+    readonly typeAssertions: readonly TypeAssertionEntity[];
+    readonly typePredicates: readonly TypePredicateEntity[];
+    readonly unsafeGenericAssertions: readonly UnsafeGenericAssertionEntity[];
+    readonly unsafeTypeAnnotations: readonly UnsafeTypeAnnotationEntity[];
+    readonly inlineImports: readonly InlineImportEntity[];
+    readonly computations: readonly ComputationEntity[];
+    readonly dependencyEdges: readonly DependencyEdge[];
+    readonly ownershipEdges: readonly OwnershipEdge[];
+    readonly variablesByName: ReadonlyMap<string, readonly VariableEntity$1[]>;
+    readonly functionsByNode: ReadonlyMap<ts.Node, FunctionEntity>;
+    readonly functionsByDeclarationNode: ReadonlyMap<ts.Node, FunctionEntity>;
+    readonly functionsByName: ReadonlyMap<string, readonly FunctionEntity[]>;
+    readonly callsByNode: ReadonlyMap<ts.CallExpression | ts.NewExpression, CallEntity>;
+    readonly callsByPrimitive: ReadonlyMap<string, readonly CallEntity[]>;
+    readonly callsByMethodName: ReadonlyMap<string, readonly CallEntity[]>;
+    readonly callsByArgNode: ReadonlyMap<ts.Node, ArgumentEntity>;
+    readonly jsxByNode: ReadonlyMap<ts.Node, JSXElementEntity>;
+    readonly jsxByTag: ReadonlyMap<string, readonly JSXElementEntity[]>;
+    readonly jsxAttributesByElementId: ReadonlyMap<number, ReadonlyMap<string, JSXAttributeEntity>>;
+    readonly jsxAttrsByKind: ReadonlyMap<JSXAttributeKind, readonly JSXAttributeWithElement$1[]>;
+    readonly jsxClassAttributes: readonly JSXAttributeWithElement$1[];
+    readonly jsxClassListAttributes: readonly JSXAttributeWithElement$1[];
+    readonly jsxStyleAttributes: readonly JSXAttributeWithElement$1[];
+    readonly fillImageElements: readonly JSXElementEntity[];
+    readonly staticClassTokensByElementId: ReadonlyMap<number, JSXStaticClassIndex$1>;
+    readonly staticClassListKeysByElementId: ReadonlyMap<number, JSXStaticObjectKeyIndex$1>;
+    readonly staticStyleKeysByElementId: ReadonlyMap<number, JSXStaticObjectKeyIndex$1>;
+    readonly classListProperties: readonly JSXObjectPropertyWithElement$1[];
+    readonly styleProperties: readonly JSXObjectPropertyWithElement$1[];
+    readonly inlineStyleClassNames: ReadonlySet<string>;
+    readonly importsBySource: ReadonlyMap<string, readonly ImportEntity[]>;
+    readonly exportsByName: ReadonlyMap<string, ExportEntity>;
+    readonly exportsByEntityId: ReadonlyMap<number, ExportEntity>;
+    readonly classesByNode: ReadonlyMap<ts.ClassDeclaration | ts.ClassExpression, ClassEntity>;
+    readonly classesByName: ReadonlyMap<string, readonly ClassEntity[]>;
+    readonly unaryExpressionsByOperator: ReadonlyMap<ts.SyntaxKind, readonly ts.PrefixUnaryExpression[]>;
+    readonly spreadElements: readonly (ts.SpreadElement | ts.SpreadAssignment)[];
+    readonly newExpressionsByCallee: ReadonlyMap<string, readonly ts.NewExpression[]>;
+    readonly deleteExpressions: readonly ts.DeleteExpression[];
+    readonly identifiersByName: ReadonlyMap<string, readonly ts.Identifier[]>;
+    readonly firstScope: ScopeEntity | null;
+    readonly componentScopes: ReadonlyMap<ScopeEntity, {
+        readonly scope: ScopeEntity;
+        readonly name: string;
+    }>;
+    readonly componentFunctions: readonly FunctionEntity[];
+    readonly functionsWithReactiveCaptures: readonly FunctionEntity[];
+    readonly reactiveVariables: readonly VariableEntity$1[];
+    readonly propsVariables: readonly VariableEntity$1[];
+    readonly storeVariables: readonly VariableEntity$1[];
+    readonly resourceVariables: readonly VariableEntity$1[];
+    readonly variablesWithPropertyAssignment: readonly VariableEntity$1[];
+    readonly computationByCallId: ReadonlyMap<number, ComputationEntity>;
+    readonly typeResolver: TypeResolver;
+    readonly fileEntity: FileEntity$1;
+    readonly lineStartOffsets: readonly number[];
+    readonly jsxContextCache: WeakMap<ts.Node, JSXContext | null>;
+    readonly scopeForCache: WeakMap<ts.Node, ScopeEntity>;
+    readonly onDepsCache: WeakMap<ts.Node, boolean>;
+    readonly passthroughCache: WeakMap<ts.Node, boolean>;
+    findExpressionAtOffset(offset: number): ts.Node | null;
+}
+
+declare function analyzeInput(input: SolidInput, emit: Emit$1): void;
+declare function runSolidRules(tree: SolidSyntaxTree, sourceFile: ts.SourceFile, emit: Emit$1): void;
+declare const SolidPlugin: Plugin<"solid">;
+
+declare function createSolidInput(filePath: string, program: ts.Program, logger?: Logger): SolidInput;
+
 /**
- * SolidGraph Implementation
+ * SolidBuildContext — mutable accumulator for solid analysis phases.
+ *
+ * Replaces the SolidGraph class. Phases call add* methods to populate entities.
+ * After all phases complete, the context is frozen into a SolidSyntaxTree.
  */
 
-/** @internal */
 interface JSXAttributeWithElement {
     readonly attr: JSXAttributeEntity;
     readonly element: JSXElementEntity;
@@ -1366,32 +1473,16 @@ interface JSXObjectPropertyWithElement {
     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 {
+interface SolidBuildContext {
     readonly kind: "solid";
+    readonly filePath: string;
+    readonly version: string;
     readonly file: string;
-    readonly logger: Logger;
     readonly sourceFile: ts.SourceFile;
-    readonly comments: readonly CommentEntry[];
     readonly typeResolver: TypeResolver;
+    readonly logger: Logger;
     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 comments: readonly CommentEntry[];
     readonly scopes: ScopeEntity[];
     readonly variables: VariableEntity$1[];
     readonly functions: FunctionEntity[];
@@ -1431,7 +1522,6 @@ declare class SolidGraph {
     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>;
@@ -1443,7 +1533,6 @@ declare class SolidGraph {
     readonly newExpressionsByCallee: Map<string, ts.NewExpression[]>;
     readonly deleteExpressions: ts.DeleteExpression[];
     readonly identifiersByName: Map<string, ts.Identifier[]>;
-    private _lineStartOffsets;
     firstScope: ScopeEntity | null;
     readonly componentScopes: Map<ScopeEntity, {
         scope: ScopeEntity;
@@ -1456,137 +1545,72 @@ declare class SolidGraph {
     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<ts.Node, JSXContext | null>;
     readonly scopeForCache: WeakMap<ts.Node, ScopeEntity>;
     readonly onDepsCache: WeakMap<ts.Node, boolean>;
     readonly passthroughCache: WeakMap<ts.Node, boolean>;
-    /**
-     * Creates a new SolidGraph instance.
-     *
-     * @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): 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: ts.PrefixUnaryExpression): void;
-    /** @internal */
     addDeleteExpression(node: ts.DeleteExpression): void;
-    /** @internal */
     addSpreadElement(node: ts.SpreadElement | ts.SpreadAssignment): void;
-    /** @internal */
     addNewExpressionByCallee(name: string, node: ts.NewExpression): void;
-    /** @internal */
     addIdentifierReference(node: ts.Identifier): void;
-    /**
-     * Line start offsets for position queries. Computed lazily — CLI lint
-     * never accesses this, so zero cost during analysis.
-     */
-    get lineStartOffsets(): readonly number[];
-    /**
-     * Find the deepest expression at a character offset using the AST.
-     * O(log n) via TypeScript's getTokenAtPosition + parent walk.
-     * Zero pre-computation — no dense array, no per-node writes during analysis.
-     */
+    readonly lineStartOffsets: readonly number[];
     findExpressionAtOffset(offset: number): ts.Node | null;
 }
 
+/**
+ * Solid analysis entry point.
+ *
+ * Builds a SolidSyntaxTree from a SolidInput by running all analysis phases
+ * against a mutable SolidBuildContext, then freezing the result.
+ */
+
+/**
+ * Build a SolidSyntaxTree from input.
+ *
+ * 1. Creates mutable SolidBuildContext
+ * 2. Runs all 9 analysis phases (scopes, entities, wiring, reactivity, etc.)
+ * 3. Freezes context into readonly SolidSyntaxTree
+ */
+declare function buildSolidSyntaxTree(input: SolidInput, version: string): SolidSyntaxTree;
+
 /**
  * Validates whether a CSS class name is a known Tailwind utility.
  *
@@ -1619,10 +1643,74 @@ interface TailwindValidator {
  * - `@tailwindcss/node` is not installed (directly or transitively)
  * - The design system fails to load
  */
-declare function resolveTailwindValidator(files: readonly {
+/**
+ * Preparation result for Tailwind resolution.
+ *
+ * Contains the data needed by the WorkspaceEvaluator subprocess to load the
+ * design system. The caller passes these fields to evaluateWorkspace().
+ */
+interface TailwindEvalParams {
+    readonly modulePath: string;
+    readonly entryCss: string;
+    readonly entryBase: string;
+}
+/**
+ * Prepare Tailwind evaluation parameters from CSS files.
+ *
+ * Detects the Tailwind entry file and resolves the @tailwindcss/node module
+ * path. Returns null if no entry is detected or the module is not installed.
+ * Does NOT spawn a subprocess — the caller does that via WorkspaceEvaluator.
+ *
+ * @param files - CSS files with content
+ * @param rootPath - Project root for module resolution
+ * @param workspacePackagePaths - Workspace package paths for module resolution
+ * @param logger - Logger
+ * @returns Evaluation parameters, or null
+ */
+declare function prepareTailwindEval(files: readonly {
+    path: string;
+    content: string;
+}[], rootPath: string, workspacePackagePaths: readonly string[], logger?: Logger): TailwindEvalParams | null;
+/**
+ * A TailwindValidator with a preloadable batch cache for arbitrary value classes.
+ *
+ * The static validator handles known utility/variant combinations.
+ * Arbitrary values (min-h-[60vh], max-w-[360px], [&_[data-slot]]:hidden, etc.)
+ * are not in the static set. The caller collects all class names that will be
+ * checked, sends them to candidatesToCss in one batch via the WorkspaceEvaluator,
+ * and preloads the results before rule execution.
+ */
+interface BatchableTailwindValidator extends TailwindValidator {
+    preloadBatch(classNames: readonly string[], results: readonly boolean[]): void;
+}
+/**
+ * Build a TailwindValidator from evaluation results with batch preloading.
+ *
+ * @param utilities - Utility class names from the design system
+ * @param variants - Variant definitions from the design system
+ * @param logger - Logger
+ * @returns BatchableTailwindValidator
+ */
+declare function buildTailwindValidatorFromEval(utilities: readonly string[], variants: readonly {
+    name: string;
+    values: string[];
+    hasDash: boolean;
+    isArbitrary: boolean;
+}[], logger?: Logger): BatchableTailwindValidator;
+/**
+ * Resolve a TailwindValidator synchronously.
+ *
+ * Uses the default Bun subprocess evaluator unless a custom one is provided.
+ *
+ * @param files - CSS files with content
+ * @param rootPath - Project root (optional, walks up to package.json if not provided)
+ * @param workspacePackagePaths - Workspace package paths (optional)
+ * @returns TailwindValidator, or null
+ */
+declare function resolveTailwindValidatorSync(files: readonly {
     path: string;
     content: string;
-}[], logger?: Logger): Promise<TailwindValidator | null>;
+}[], rootPath?: string, workspacePackagePaths?: readonly string[]): BatchableTailwindValidator | null;
 
 /**
  * CSSInput - Input type for building CSSGraph from CSS/SCSS source files.
@@ -1645,26 +1733,20 @@ interface CSSFile {
  * 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>;
+    readonly options: CSSOptions;
+    readonly tailwind: TailwindValidator | null;
+    readonly logger: Logger;
+    readonly externalCustomProperties: ReadonlySet<string> | null;
+}
+interface CSSInputBuilder {
+    files: readonly CSSFile[];
+    options: CSSOptions;
+    tailwind: TailwindValidator | null;
+    logger: Logger;
+    externalCustomProperties: ReadonlySet<string> | null;
 }
+declare function createCSSInput(files: readonly CSSFile[]): CSSInputBuilder;
 /**
  * Options for CSS graph building.
  */
@@ -1697,6 +1779,8 @@ interface TokenPatternConfig {
     }[];
 }
 
+declare const CSSPlugin: Plugin<"css">;
+
 /**
  * CSS Specificity Types
  */
@@ -2241,37 +2325,150 @@ interface CSSParseError {
 }
 
 /**
- * CSSGraphImpl - CSS Program Graph Implementation
+ * CSSWorkspaceView — readonly interface for CSS rules and queries.
  *
+ * Replaces CSSGraph as the type received by CSS rules and query functions.
+ * Contains every read-only field and query method that rules/queries access.
  */
 
-/**
- * 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[];
+interface CSSWorkspaceView {
+    readonly options: CSSOptions;
+    readonly interner: StringInterner;
+    readonly logger: Logger;
+    readonly tailwind: TailwindValidator | null;
+    readonly hasScssFiles: boolean;
+    readonly files: readonly FileEntity[];
+    readonly rules: readonly RuleEntity[];
+    readonly selectors: readonly SelectorEntity[];
     readonly declarations: readonly DeclarationEntity[];
+    readonly variables: readonly VariableEntity[];
+    readonly variableRefs: readonly VariableReferenceEntity[];
+    readonly atRules: readonly AtRuleEntity[];
+    readonly tokens: readonly ThemeTokenEntity[];
+    readonly mixins: readonly MixinEntity[];
+    readonly includes: readonly MixinIncludeEntity[];
+    readonly functions: readonly SCSSFunctionEntity[];
+    readonly functionCalls: readonly FunctionCallEntity[];
+    readonly placeholders: readonly PlaceholderEntity[];
+    readonly extends: readonly ExtendEntity[];
+    readonly filesByPath: ReadonlyMap<string, FileEntity>;
+    readonly variablesByName: ReadonlyMap<string, readonly VariableEntity[]>;
+    readonly rulesBySelector: ReadonlyMap<string, readonly RuleEntity[]>;
+    readonly mixinsByName: ReadonlyMap<string, MixinEntity>;
+    readonly functionsByName: ReadonlyMap<string, SCSSFunctionEntity>;
+    readonly placeholdersByName: ReadonlyMap<string, PlaceholderEntity>;
+    readonly layerOrder: ReadonlyMap<string, number>;
+    readonly declarationsByProperty: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly atRulesByName: ReadonlyMap<string, readonly AtRuleEntity[]>;
+    readonly atRulesByKind: ReadonlyMap<AtRuleKind, readonly AtRuleEntity[]>;
+    readonly atRulesByNode: ReadonlyMap<AtRule, AtRuleEntity>;
+    readonly rulesByNode: ReadonlyMap<Rule, RuleEntity>;
+    readonly duplicateSelectors: ReadonlyMap<string, {
+        readonly selector: string;
+        readonly rules: readonly RuleEntity[];
+    }>;
+    readonly tokensByCategory: ReadonlyMap<TokenCategory, readonly ThemeTokenEntity[]>;
+    readonly importantDeclarations: readonly DeclarationEntity[];
+    readonly globalVariables: readonly VariableEntity[];
+    readonly unusedVariables: readonly VariableEntity[];
+    readonly scssVariables: readonly VariableEntity[];
+    readonly cssCustomProperties: readonly VariableEntity[];
+    readonly unresolvedRefs: readonly VariableReferenceEntity[];
+    readonly mediaQueries: readonly AtRuleEntity[];
+    readonly keyframes: readonly AtRuleEntity[];
+    readonly layers: readonly AtRuleEntity[];
+    readonly fontFaces: readonly AtRuleEntity[];
+    readonly supportsRules: readonly AtRuleEntity[];
+    readonly unusedKeyframes: readonly AtRuleEntity[];
+    readonly unusedMixins: readonly MixinEntity[];
+    readonly unresolvedMixinIncludes: readonly MixinIncludeEntity[];
+    readonly unusedFunctions: readonly SCSSFunctionEntity[];
+    readonly unusedPlaceholders: readonly PlaceholderEntity[];
+    readonly unresolvedExtends: readonly ExtendEntity[];
+    readonly parseErrors: readonly CSSParseError[];
+    readonly failedFilePaths: readonly string[];
+    readonly tokenCategories: readonly TokenCategory[];
+    readonly selectorsByPseudoClass: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly idSelectors: readonly SelectorEntity[];
+    readonly attributeSelectors: readonly SelectorEntity[];
+    readonly universalSelectors: readonly SelectorEntity[];
+    readonly classNameIndex: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly selectorsBySubjectTag: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly selectorsWithoutSubjectTag: readonly SelectorEntity[];
+    readonly selectorsTargetingCheckbox: readonly SelectorEntity[];
+    readonly selectorsTargetingTableCell: readonly SelectorEntity[];
+    readonly knownKeyframeNames: ReadonlySet<string>;
+    readonly unresolvedAnimationRefs: readonly UnresolvedAnimationRef[];
+    readonly declaredContainerNames: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly containerQueryNames: ReadonlyMap<string, readonly AtRuleEntity[]>;
+    readonly unusedContainerNames: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly unknownContainerQueries: readonly AtRuleEntity[];
+    readonly multiDeclarationProperties: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly keyframeDeclarations: readonly DeclarationEntity[];
+    readonly layoutPropertiesByClassToken: ReadonlyMap<string, readonly string[]>;
+    readonly keyframeLayoutMutationsByName: ReadonlyMap<string, readonly KeyframeLayoutMutation$1[]>;
+    readonly fontFaceDescriptorsByFamily: ReadonlyMap<string, readonly FontFaceDescriptor[]>;
+    readonly usedFontFamiliesByRule: ReadonlyMap<number, readonly string[]>;
+    readonly usedFontFamilies: ReadonlySet<string>;
+    readonly filesWithLayers: ReadonlySet<string>;
+    readonly emptyRules: readonly RuleEntity[];
+    readonly emptyKeyframes: readonly AtRuleEntity[];
+    readonly overqualifiedSelectors: readonly SelectorEntity[];
+    readonly deepNestedRules: readonly RuleEntity[];
+    declarationsForProperties(...properties: string[]): 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 {
+
+interface CSSSyntaxTree {
     readonly kind: "css";
+    readonly filePath: string;
+    readonly version: string;
+    readonly isScss: boolean;
+    readonly file: FileEntity;
+    readonly rules: readonly RuleEntity[];
+    readonly selectors: readonly SelectorEntity[];
+    readonly declarations: readonly DeclarationEntity[];
+    readonly variables: readonly VariableEntity[];
+    readonly variableRefs: readonly VariableReferenceEntity[];
+    readonly atRules: readonly AtRuleEntity[];
+    readonly tokens: readonly ThemeTokenEntity[];
+    readonly mixins: readonly MixinEntity[];
+    readonly includes: readonly MixinIncludeEntity[];
+    readonly functions: readonly SCSSFunctionEntity[];
+    readonly functionCalls: readonly FunctionCallEntity[];
+    readonly placeholders: readonly PlaceholderEntity[];
+    readonly extends: readonly ExtendEntity[];
+    readonly parseErrors: readonly CSSParseError[];
+    readonly unresolvedRefs: readonly VariableReferenceEntity[];
+    readonly unresolvedMixinIncludes: readonly MixinIncludeEntity[];
+    readonly unresolvedExtends: readonly ExtendEntity[];
+    readonly rulesBySelector: ReadonlyMap<string, readonly RuleEntity[]>;
+    readonly rulesByNode: ReadonlyMap<Rule, RuleEntity>;
+    readonly variablesByName: ReadonlyMap<string, readonly VariableEntity[]>;
+    readonly declarationsByProperty: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly atRulesByName: ReadonlyMap<string, readonly AtRuleEntity[]>;
+    readonly atRulesByKind: ReadonlyMap<AtRuleKind, readonly AtRuleEntity[]>;
+    readonly atRulesByNode: ReadonlyMap<AtRule, AtRuleEntity>;
+    readonly classNameIndex: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly selectorsBySubjectTag: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly selectorsByPseudoClass: ReadonlyMap<string, readonly SelectorEntity[]>;
+    readonly selectorsWithoutSubjectTag: readonly SelectorEntity[];
+    readonly filesByPath: ReadonlyMap<string, FileEntity>;
+    readonly sourceOrderBase: number;
+}
+
+/**
+ * CSSBuildContext — mutable accumulator for CSS analysis phases.
+ *
+ * Replaces the CSSGraph class. Phases call add* methods to populate entities.
+ * After all phases complete, buildDerivedIndexes() is called, then the context
+ * is frozen into CSSSyntaxTree[] + CSSWorkspaceView.
+ */
+
+interface CSSBuildContext {
     readonly options: CSSOptions;
     readonly interner: StringInterner;
     readonly logger: Logger;
+    readonly tailwind: TailwindValidator | null;
     sourceOrder: number;
     hasScssFiles: boolean;
     readonly files: FileEntity[];
@@ -2291,7 +2488,6 @@ declare class CSSGraph {
     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>;
@@ -2327,27 +2523,7 @@ declare class CSSGraph {
     readonly parseErrors: CSSParseError[];
     readonly failedFilePaths: string[];
     readonly tokenCategories: TokenCategory[];
-    private _filesWithLayers;
-    get filesWithLayers(): ReadonlySet<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, zero nested rules, and zero nested at-rules. */
-    private _emptyRules;
-    get emptyRules(): readonly RuleEntity[];
-    /** @keyframes at-rules with no effective keyframe declarations. */
-    private _emptyKeyframes;
-    get emptyKeyframes(): readonly AtRuleEntity[];
-    private _overqualifiedSelectors;
-    get overqualifiedSelectors(): readonly SelectorEntity[];
     readonly idSelectors: SelectorEntity[];
     readonly attributeSelectors: SelectorEntity[];
     readonly universalSelectors: SelectorEntity[];
@@ -2356,17 +2532,19 @@ declare class CSSGraph {
     readonly selectorsWithoutSubjectTag: SelectorEntity[];
     readonly selectorsTargetingCheckbox: SelectorEntity[];
     readonly selectorsTargetingTableCell: 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[];
+    readonly multiDeclarationProperties: Map<string, readonly DeclarationEntity[]>;
+    readonly keyframeDeclarations: DeclarationEntity[];
     readonly layoutPropertiesByClassToken: Map<string, readonly string[]>;
-    readonly keyframeLayoutMutationsByName: Map<string, readonly KeyframeLayoutMutation[]>;
+    readonly keyframeLayoutMutationsByName: Map<string, readonly KeyframeLayoutMutation$1[]>;
     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;
-    private _deepNestedRules;
-    get deepNestedRules(): readonly RuleEntity[];
-    constructor(input: CSSInput);
-    intern(s: string): string;
     nextFileId(): number;
     nextRuleId(): number;
     nextSelectorId(): number;
@@ -2382,6 +2560,7 @@ declare class CSSGraph {
     nextPlaceholderId(): number;
     nextExtendId(): number;
     nextSourceOrder(): number;
+    intern(s: string): string;
     addFile(file: FileEntity): void;
     addRule(rule: RuleEntity): void;
     addSelector(selector: SelectorEntity): void;
@@ -2400,197 +2579,647 @@ declare class CSSGraph {
     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 buildContainingMediaStacks;
-    private buildKeyframeIndexes;
-    private buildContainerNameIndexes;
-    /**
-     * Sort each declarationsByProperty list by sourceOrder and populate
-     * multiDeclarationProperties with only those having 2+ entries.
-     */
-    private buildMultiDeclarationProperties;
-    private buildLayoutPropertiesByClassToken;
-    private buildFontIndexes;
     buildUnusedIndexes(): void;
+    readonly filesWithLayers: ReadonlySet<string>;
+    readonly emptyRules: readonly RuleEntity[];
+    readonly emptyKeyframes: readonly AtRuleEntity[];
+    readonly overqualifiedSelectors: readonly SelectorEntity[];
+    readonly deepNestedRules: readonly RuleEntity[];
 }
 
-interface ReservoirSampler {
-    readonly buffer: number[];
-    count: number;
-    readonly capacity: number;
-}
-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: ReservoirSampler;
-    uncertaintyEscalations: number;
-    signalSnapshotsBuilt: number;
-    signalSnapshotCacheHits: number;
-    measurementIndexHits: number;
-    contextsClassified: number;
-    diagnosticsEmitted: number;
-    selectorIndexMs: number;
-    selectorMatchMs: number;
-    cascadeBuildMs: number;
-    caseBuildMs: number;
-    scoringMs: number;
-    elapsedMs: number;
+interface UnresolvedAnimationRef {
+    readonly declaration: DeclarationEntity;
+    readonly name: string;
 }
-
-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";
-declare const enum ContextCertainty {
-    Resolved = 0,
-    Conditional = 1,
-    Unknown = 2
+interface KeyframeLayoutMutation$1 {
+    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;
+}
+interface CSSBuildResult {
+    readonly trees: readonly CSSSyntaxTree[];
+    readonly workspace: CSSWorkspaceView;
 }
+declare function buildCSSResult(input: CSSInput): CSSBuildResult;
+
+/**
+ * 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. Receive dependency names from WorkspaceLayout (single source of truth)
+ * 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
+ */
+
 /**
- * Whether the CSS formatting context consults baselines for vertical positioning.
+ * Scan installed dependencies for CSS custom properties they inject at runtime.
  *
- * - `"relevant"`: Baselines participate in alignment (e.g. flex `align-items: baseline`,
- *   table-cell `vertical-align: baseline`, inline formatting context).
- * - `"irrelevant"`: The alignment model is purely geometric; baselines are never
- *   consulted (e.g. flex `align-items: center`, table-cell `vertical-align: middle`
- *   with uniform cohort agreement).
+ * Receives dependency names from WorkspaceLayout instead of re-reading
+ * package.json files. Uses layout.root for node_modules resolution.
  *
- * Computed once at context construction for flex/grid (parent-level data suffices).
- * For table-cell contexts, finalized after cohort aggregation when the cohort's
- * vertical-align consensus is known.
+ * @param layout - Workspace layout with pre-resolved dependency names
+ * @returns Set of CSS custom property names (e.g., "--kb-accordion-content-height")
+ */
+declare function scanDependencyCustomProperties(layout: WorkspaceLayout): ReadonlySet<string>;
+
+/**
+ * Accessibility Policy Templates
  *
- * CSS spec references:
- * - Flex: CSS Flexbox §8.3, §9.6 — `center` aligns by margin box center, not baselines.
- * - Grid: CSS Grid §10.6 — analogous to flex.
- * - Table: CSS2 §17.5.3 — `middle` centers cell content geometrically.
+ * Predefined bundles of sizing, spacing, and contrast constraints
+ * derived from WCAG 2.2, Material Design 3, Apple HIG, and
+ * W3C Low Vision Needs.
  */
-type BaselineRelevance = "relevant" | "irrelevant";
-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;
-    /**
-     * Whether the layout container's cross axis aligns with the document's
-     * block axis. When `true`, vertical sibling offset differences represent
-     * genuine alignment issues. When `false`, the block axis is the container's
-     * main axis — vertical positioning is controlled by the layout algorithm
-     * (gap, justify-content), and offset evidence should be suppressed.
-     *
-     * For non-flex/grid contexts (block flow, inline formatting, table-cell),
-     * this is always `true`.
-     */
-    readonly crossAxisIsBlockAxis: boolean;
-    readonly crossAxisIsBlockAxisCertainty: ContextCertainty;
-    readonly baselineRelevance: BaselineRelevance;
-    readonly evidence: LayoutContextEvidence;
-}
 
-declare const layoutSignalNames: readonly ["line-height", "font-size", "width", "inline-size", "height", "block-size", "min-width", "min-block-size", "min-height", "max-width", "max-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", "flex-direction", "flex-basis", "grid-auto-flow", "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", "contain"];
-type LayoutSignalName = (typeof layoutSignalNames)[number];
-declare const enum LayoutSignalSource {
-    Selector = 0,
-    InlineStyle = 1
+/** Set the active policy for all policy rules. Pass null to disable. */
+declare function setActivePolicy(name: string | null): void;
+
+interface TailwindSymbolContribution {
+    readonly classNames: ReadonlyMap<string, ClassNameSymbol>;
 }
-declare const enum LayoutSignalGuard {
-    Unconditional = 0,
+interface TailwindParsedCandidate {
+    readonly raw: string;
+    readonly variants: readonly TailwindParsedVariant[];
+    readonly utility: string;
+    readonly value: TailwindCandidateValue | null;
+    readonly modifier: TailwindCandidateModifier | null;
+    readonly important: boolean;
+    readonly negative: boolean;
+}
+interface TailwindParsedVariant {
+    readonly name: string;
+    readonly kind: "static" | "functional" | "compound" | "arbitrary";
+    readonly value: string | null;
+    readonly modifier: string | null;
+}
+interface TailwindCandidateValue {
+    readonly kind: "named" | "arbitrary" | "fraction";
+    readonly value: string;
+    readonly dashedIdent: string | null;
+}
+interface TailwindCandidateModifier {
+    readonly kind: "named" | "arbitrary";
+    readonly value: string;
+}
+interface TailwindResolvedDeclaration {
+    readonly property: string;
+    readonly value: string;
+}
+type TailwindCandidateDiagnostic = {
+    readonly kind: "unknown-utility";
+    readonly utility: string;
+} | {
+    readonly kind: "invalid-variant";
+    readonly variant: string;
+} | {
+    readonly kind: "theme-token-not-found";
+    readonly token: string;
+} | {
+    readonly kind: "invalid-arbitrary-value";
+    readonly value: string;
+} | {
+    readonly kind: "incompatible-compound-variant";
+    readonly variant: string;
+    readonly parent: string;
+};
+type TailwindCandidateResult = {
+    readonly valid: true;
+    readonly candidate: TailwindParsedCandidate;
+    readonly symbol: ClassNameSymbol;
+} | {
+    readonly valid: false;
+    readonly diagnostics: readonly TailwindCandidateDiagnostic[];
+};
+interface TailwindResolution {
+    readonly candidate: TailwindParsedCandidate;
+    readonly css: string;
+    readonly declarations: readonly TailwindResolvedDeclaration[];
+}
+interface TailwindVariantInfo {
+    readonly name: string;
+    readonly kind: "static" | "functional" | "compound" | "arbitrary";
+    readonly values: readonly string[];
+    readonly hasDash: boolean;
+    readonly isArbitrary: boolean;
+    readonly order: number;
+}
+interface TailwindDesignSystem {
+    candidatesToCss(classes: string[]): (string | null)[];
+    getClassList(): [string, {
+        modifiers: string[];
+    }][];
+    getVariants(): {
+        name: string;
+        values: string[];
+        hasDash: boolean;
+        isArbitrary: boolean;
+    }[];
+}
+interface TailwindProvider {
+    readonly kind: "tailwind";
+    readonly designSystem: TailwindDesignSystem;
+    parseCandidate(candidate: string): TailwindCandidateResult;
+    has(className: string): boolean;
+    resolve(className: string): TailwindResolution | null;
+    getUtilitySymbols(): TailwindSymbolContribution;
+    getVariants(): readonly TailwindVariantInfo[];
+}
+
+interface CSSClassNameSource {
+    readonly kind: "css";
+    readonly selectors: readonly SelectorEntity[];
+    readonly filePaths: readonly string[];
+}
+interface TailwindClassNameSource {
+    readonly kind: "tailwind";
+    readonly candidate: TailwindParsedCandidate;
+    readonly resolvedCSS: string | null;
+    readonly declarations: readonly TailwindResolvedDeclaration[];
+    readonly diagnostics: readonly TailwindCandidateDiagnostic[];
+}
+type ClassNameSource = CSSClassNameSource | TailwindClassNameSource;
+interface ClassNameSymbol {
+    readonly symbolKind: "className";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly source: ClassNameSource;
+}
+
+/**
+ * Selector symbol + compiled matcher.
+ *
+ * compileSelectorMatcher moved from cross-file/layout/selector-match.ts.
+ */
+
+interface CompoundPseudoConstraints {
+    readonly firstChild: boolean;
+    readonly lastChild: boolean;
+    readonly onlyChild: boolean;
+    readonly nthChild: NthPattern | null;
+    readonly nthLastChild: NthPattern | null;
+    readonly nthOfType: NthPattern | null;
+    readonly nthLastOfType: NthPattern | null;
+    readonly anyOfGroups: readonly (readonly CompiledSelectorCompound[])[];
+    readonly noneOfGroups: readonly (readonly CompiledSelectorCompound[])[];
+}
+interface CompiledSelectorCompound {
+    readonly tagName: string | null;
+    readonly idValue: string | null;
+    readonly classes: readonly string[];
+    readonly attributes: readonly SelectorAttributeConstraint[];
+    readonly pseudo: CompoundPseudoConstraints;
+}
+interface SelectorSubjectConstraintSummary {
+    readonly idValue: string | null;
+    readonly classes: readonly string[];
+    readonly attributeNames: readonly string[];
+    readonly hasStructuralPseudo: boolean;
+}
+interface SelectorFeatureRequirements {
+    readonly needsClassTokens: boolean;
+    readonly needsAttributes: boolean;
+}
+interface CompiledSelectorMatcher {
+    readonly subjectTag: string | null;
+    readonly subject: SelectorSubjectConstraintSummary;
+    readonly requirements: SelectorFeatureRequirements;
+    readonly compoundsRightToLeft: readonly CompiledSelectorCompound[];
+    readonly combinatorsRightToLeft: readonly CombinatorType[];
+}
+interface SelectorSymbol {
+    readonly symbolKind: "selector";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: SelectorEntity;
+    readonly specificity: readonly [number, number, number];
+    readonly dispatchKeys: readonly string[];
+    readonly compiledMatcher: CompiledSelectorMatcher | null;
+}
+
+interface DeclarationSymbol {
+    readonly symbolKind: "declaration";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: DeclarationEntity;
+    readonly sourceOrder: number;
+    readonly layerOrder: number;
+}
+
+interface CustomPropertySymbol {
+    readonly symbolKind: "customProperty";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: VariableEntity;
+    readonly isGlobal: boolean;
+    readonly isScss: boolean;
+    readonly references: readonly VariableReferenceEntity[];
+    readonly resolvedValue: string | null;
+}
+
+interface KeyframeLayoutMutation {
+    readonly property: string;
+    readonly values: readonly string[];
+    readonly declarations: readonly DeclarationEntity[];
+}
+interface KeyframesSymbol {
+    readonly symbolKind: "keyframes";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: AtRuleEntity;
+    readonly layoutMutations: readonly KeyframeLayoutMutation[];
+}
+
+interface FontFaceSymbol {
+    readonly symbolKind: "fontFace";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: AtRuleEntity;
+    readonly family: string;
+    readonly display: string | null;
+    readonly hasWebFontSource: boolean;
+    readonly hasEffectiveMetricOverrides: boolean;
+}
+
+interface LayerSymbol {
+    readonly symbolKind: "layer";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: AtRuleEntity;
+    readonly order: number;
+}
+
+interface ContainerSymbol {
+    readonly symbolKind: "container";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly declarations: readonly DeclarationEntity[];
+    readonly queries: readonly AtRuleEntity[];
+}
+
+interface ThemeTokenSymbol {
+    readonly symbolKind: "themeToken";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly entity: ThemeTokenEntity;
+    readonly category: string;
+}
+
+interface ComponentHostSymbol {
+    readonly symbolKind: "componentHost";
+    readonly name: string;
+    readonly filePath: string | null;
+    readonly importSource: string;
+    readonly exportName: string;
+    readonly hostTag: string | null;
+    readonly hostClassTokens: readonly string[];
+    readonly hostAttributes: ReadonlyMap<string, string | null>;
+    readonly resolvedFilePath: string;
+}
+
+interface SymbolTable {
+    readonly classNames: ReadonlyMap<string, ClassNameSymbol>;
+    readonly selectors: ReadonlyMap<number, SelectorSymbol>;
+    readonly customProperties: ReadonlyMap<string, CustomPropertySymbol>;
+    readonly componentHosts: ReadonlyMap<string, ComponentHostSymbol>;
+    readonly keyframes: ReadonlyMap<string, KeyframesSymbol>;
+    readonly fontFaces: ReadonlyMap<string, readonly FontFaceSymbol[]>;
+    readonly layers: ReadonlyMap<string, LayerSymbol>;
+    readonly containers: ReadonlyMap<string, ContainerSymbol>;
+    readonly themeTokens: ReadonlyMap<string, ThemeTokenSymbol>;
+    readonly selectorsByDispatchKey: ReadonlyMap<string, readonly SelectorSymbol[]>;
+    readonly selectorsBySubjectTag: ReadonlyMap<string, readonly SelectorSymbol[]>;
+    readonly selectorsWithoutSubjectTag: readonly SelectorSymbol[];
+    readonly declarationsByProperty: ReadonlyMap<string, readonly DeclarationSymbol[]>;
+    declarationsForProperties(...properties: string[]): readonly DeclarationEntity[];
+    readonly duplicateSelectors: ReadonlyMap<string, {
+        readonly selector: string;
+        readonly rules: readonly RuleEntity[];
+    }>;
+    readonly multiDeclarationProperties: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly layoutPropertiesByClassToken: ReadonlyMap<string, readonly string[]>;
+    readonly usedFontFamilies: ReadonlySet<string>;
+    readonly usedFontFamiliesByRule: ReadonlyMap<number, readonly string[]>;
+    readonly idSelectors: readonly SelectorEntity[];
+    readonly attributeSelectors: readonly SelectorEntity[];
+    readonly universalSelectors: readonly SelectorEntity[];
+    readonly selectorsTargetingCheckbox: readonly SelectorEntity[];
+    readonly selectorsTargetingTableCell: readonly SelectorEntity[];
+    readonly importantDeclarations: readonly DeclarationEntity[];
+    readonly emptyRules: readonly RuleEntity[];
+    readonly emptyKeyframes: readonly AtRuleEntity[];
+    readonly deepNestedRules: readonly RuleEntity[];
+    readonly overqualifiedSelectors: readonly SelectorEntity[];
+    readonly unresolvedAnimationRefs: readonly {
+        readonly declaration: DeclarationEntity;
+        readonly name: string;
+    }[];
+    readonly unknownContainerQueries: readonly AtRuleEntity[];
+    readonly unusedContainerNames: ReadonlyMap<string, readonly DeclarationEntity[]>;
+    readonly keyframeDeclarations: readonly DeclarationEntity[];
+    readonly tokensByCategory: ReadonlyMap<string, readonly ThemeTokenEntity[]>;
+    readonly mixinsByName: ReadonlyMap<string, MixinEntity>;
+    readonly functionsByName: ReadonlyMap<string, SCSSFunctionEntity>;
+    readonly placeholdersByName: ReadonlyMap<string, PlaceholderEntity>;
+    readonly unusedVariables: readonly VariableEntity[];
+    readonly unusedKeyframes: readonly AtRuleEntity[];
+    readonly unusedMixins: readonly MixinEntity[];
+    readonly unusedFunctions: readonly SCSSFunctionEntity[];
+    readonly unusedPlaceholders: readonly PlaceholderEntity[];
+    readonly tokenCategories: readonly string[];
+    hasClassName(name: string): boolean;
+    getClassName(name: string): ClassNameSymbol | null;
+    getSelectorsByClassName(name: string): readonly SelectorSymbol[];
+    getCustomProperty(name: string): CustomPropertySymbol | null;
+    getKeyframes(name: string): KeyframesSymbol | null;
+    getFontFaces(family: string): readonly FontFaceSymbol[];
+    getLayerOrder(name: string): number;
+}
+
+type DependencyEdgeKind = "js-import" | "css-import" | "css-at-import" | "colocated" | "global-side-effect";
+interface DependencyEdgeInfo {
+    readonly target: string;
+    readonly kind: DependencyEdgeKind;
+}
+interface ComponentImportEdge {
+    readonly importerFile: string;
+    readonly importedName: string;
+}
+interface DependencyGraph {
+    getDirectDependencies(filePath: string): readonly DependencyEdgeInfo[];
+    getReverseDependencies(filePath: string): readonly string[];
+    getCSSScope(solidFilePath: string): readonly string[];
+    getComponentImporters(solidFilePath: string): readonly ComponentImportEdge[];
+    getTransitivelyAffected(filePath: string): readonly string[];
+    isInCSSScope(solidFilePath: string, cssFilePath: string): boolean;
+}
+
+/**
+ * Scoped selector index type + construction (Phase 6 adds buildScopedSelectorIndex).
+ */
+
+interface ScopedSelectorIndex {
+    readonly byDispatchKey: ReadonlyMap<string, readonly SelectorSymbol[]>;
+    readonly byTagName: ReadonlyMap<string, readonly SelectorSymbol[]>;
+    readonly requirements: {
+        readonly needsClassTokens: boolean;
+        readonly needsAttributes: boolean;
+    };
+}
+
+/**
+ * Layout fact types + computation from signal snapshots.
+ *
+ * Moved from cross-file/layout/build.ts steps 6-7.
+ */
+
+type LayoutFactKind = "reservedSpace" | "scrollContainer" | "flowParticipation" | "containingBlock";
+interface LayoutFactMap {
+    reservedSpace: ReservedSpaceFact;
+    scrollContainer: ScrollContainerFact;
+    flowParticipation: FlowParticipationFact;
+    containingBlock: ContainingBlockFact;
+}
+interface ReservedSpaceFact {
+    readonly hasReservedSpace: boolean;
+    readonly reasons: readonly string[];
+    readonly hasContainIntrinsicSize: boolean;
+    readonly hasUsableAspectRatio: boolean;
+    readonly hasDeclaredInlineDimension: boolean;
+    readonly hasDeclaredBlockDimension: boolean;
+}
+interface ScrollContainerFact {
+    readonly isScrollContainer: boolean;
+    readonly axis: number;
+    readonly overflow: string | null;
+    readonly overflowY: string | null;
+    readonly hasConditionalScroll: boolean;
+    readonly hasUnconditionalScroll: boolean;
+}
+interface FlowParticipationFact {
+    readonly inFlow: boolean;
+    readonly position: string | null;
+    readonly hasConditionalOutOfFlow: boolean;
+    readonly hasUnconditionalOutOfFlow: boolean;
+}
+interface ContainingBlockFact {
+    readonly nearestPositionedAncestorKey: string | null;
+    readonly nearestPositionedAncestorHasReservedSpace: boolean;
+}
+
+/**
+ * Cascade binding types + lazy per-element cascade resolution.
+ *
+ * Moved from cross-file/layout/cascade-builder.ts + selector-match.ts matching.
+ */
+
+declare const enum SignalSource {
+    Selector = 0,
+    InlineStyle = 1
+}
+declare const enum SignalGuardKind {
+    Unconditional = 0,
     Conditional = 1
 }
-declare const enum LayoutSignalUnit {
-    Px = 0,
-    Unitless = 1,
-    Keyword = 2,
-    Unknown = 3
+type GuardConditionKind = "media" | "supports" | "container" | "dynamic-attribute";
+interface GuardConditionProvenance {
+    readonly kind: GuardConditionKind;
+    readonly query: string | null;
+    readonly key: string;
+}
+type RuleGuard = {
+    readonly kind: SignalGuardKind.Unconditional;
+    readonly conditions: readonly GuardConditionProvenance[];
+    readonly key: "always";
+} | {
+    readonly kind: SignalGuardKind.Conditional;
+    readonly conditions: readonly GuardConditionProvenance[];
+    readonly key: string;
+};
+interface CascadedDeclaration {
+    readonly value: string;
+    readonly source: SignalSource;
+    readonly guardProvenance: RuleGuard;
+}
+interface SelectorMatch {
+    readonly selectorId: number;
+    readonly specificityScore: number;
+    readonly sourceOrder: number;
+    readonly conditionalMatch: boolean;
 }
+interface ElementCascade {
+    readonly elementId: number;
+    readonly declarations: ReadonlyMap<string, CascadedDeclaration>;
+    readonly edges: readonly SelectorMatch[];
+}
+
+/**
+ * Signal snapshot types + construction.
+ *
+ * Moved from cross-file/layout/signal-normalization.ts + signal-collection.ts.
+ */
+
+declare const layoutSignalNames: readonly ["line-height", "font-size", "width", "inline-size", "height", "block-size", "min-width", "min-block-size", "min-height", "max-width", "max-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", "flex-direction", "flex-basis", "grid-auto-flow", "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", "contain"];
+type LayoutSignalName = (typeof layoutSignalNames)[number];
 declare const enum SignalValueKind {
     Known = 0,
     Unknown = 1
 }
+declare const enum SignalUnit {
+    Px = 0,
+    Unitless = 1,
+    Keyword = 2,
+    Unknown = 3
+}
 declare const enum SignalQuality {
     Exact = 0,
     Estimated = 1
 }
-interface LayoutKnownSignalValue {
+interface KnownSignalValue {
     readonly kind: SignalValueKind.Known;
     readonly name: LayoutSignalName;
     readonly normalized: string;
-    readonly source: LayoutSignalSource;
-    readonly guard: LayoutRuleGuard;
-    readonly unit: LayoutSignalUnit;
+    readonly source: SignalSource;
+    readonly guard: RuleGuard;
+    readonly unit: SignalUnit;
     readonly px: number | null;
     readonly quality: SignalQuality;
 }
-interface LayoutUnknownSignalValue {
+interface UnknownSignalValue {
     readonly kind: SignalValueKind.Unknown;
     readonly name: LayoutSignalName;
-    readonly source: LayoutSignalSource | null;
-    readonly guard: LayoutRuleGuard;
+    readonly source: SignalSource | null;
+    readonly guard: RuleGuard;
     readonly reason: string;
 }
-type LayoutSignalValue = LayoutKnownSignalValue | LayoutUnknownSignalValue;
-declare const enum LayoutTextualContentState {
+type SignalValue = KnownSignalValue | UnknownSignalValue;
+interface SignalSnapshot {
+    readonly elementId: number;
+    readonly signals: ReadonlyMap<LayoutSignalName, SignalValue>;
+    readonly knownSignalCount: number;
+    readonly unknownSignalCount: number;
+    readonly conditionalSignalCount: number;
+}
+declare const enum TextualContentState {
     Yes = 0,
     No = 1,
     Unknown = 2,
     DynamicText = 3
 }
-interface LayoutSignalSnapshot {
-    readonly node: LayoutElementNode;
-    readonly signals: ReadonlyMap<LayoutSignalName, LayoutSignalValue>;
-    readonly knownSignalCount: number;
-    readonly unknownSignalCount: number;
-    readonly conditionalSignalCount: number;
-}
-interface AlignmentElementEvidence {
+
+interface ElementNode {
+    readonly key: string;
     readonly solidFile: string;
-    readonly elementKey: string;
     readonly elementId: number;
+    readonly jsxEntity: JSXElementEntity;
     readonly tag: string | null;
-    readonly snapshot: LayoutSignalSnapshot;
+    readonly tagName: string | null;
+    readonly classTokens: readonly string[];
+    readonly classTokenSet: ReadonlySet<string>;
+    readonly inlineStyleKeys: readonly string[];
+    readonly parentElementNode: ElementNode | null;
+    readonly childElementNodes: readonly ElementNode[];
+    readonly previousSiblingNode: ElementNode | 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: TextualContentState;
+    readonly isControl: boolean;
+    readonly isReplaced: boolean;
+}
+
+interface ConditionalSignalDelta {
+    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;
+}
+
+/**
+ * Alignment model types + computation.
+ *
+ * Moved from cross-file/layout/context-classification.ts + cohort-index.ts +
+ * measurement-node.ts + content-composition.ts + consistency-domain.ts +
+ * offset.ts + signal-access helpers + util helpers.
+ */
+
+type AlignmentContextKind = "inline-formatting" | "table-cell" | "flex-cross-axis" | "grid-cross-axis" | "block-flow" | "positioned-offset";
+type LayoutAxisModel = "horizontal-tb" | "vertical-rl" | "vertical-lr";
+type InlineDirectionModel = "ltr" | "rtl";
+type LayoutContextContainerKind = "table" | "flex" | "grid" | "inline" | "block";
+declare const enum ContextCertainty {
+    Resolved = 0,
+    Conditional = 1,
+    Unknown = 2
+}
+type BaselineRelevance = "relevant" | "irrelevant";
+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 crossAxisIsBlockAxis: boolean;
+    readonly crossAxisIsBlockAxisCertainty: ContextCertainty;
+    readonly baselineRelevance: BaselineRelevance;
+    readonly evidence: LayoutContextEvidence;
+}
+declare const enum EvidenceValueKind {
+    Exact = 0,
+    Interval = 1,
+    Conditional = 2,
+    Unknown = 3
+}
+interface EvidenceWitness<T> {
+    readonly value: T | null;
+    readonly kind: EvidenceValueKind;
 }
+type NumericEvidenceValue = EvidenceWitness<number>;
 declare const enum AlignmentTextContrast {
     Different = 0,
     Same = 1,
@@ -2625,19 +3254,37 @@ interface CohortIdentifiability {
     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;
+declare const enum ContentCompositionClassification {
+    TextOnly = 0,
+    ReplacedOnly = 1,
+    MixedUnmitigated = 2,
+    MixedMitigated = 3,
+    BlockSegmented = 4,
+    Unknown = 5
 }
-interface AlignmentCohortFactSummary {
-    readonly exact: number;
+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;
+}
+interface AlignmentElementEvidence {
+    readonly solidFile: string;
+    readonly elementKey: string;
+    readonly elementId: number;
+    readonly tag: string | null;
+    readonly snapshot: SignalSnapshot;
+}
+interface CohortFactSummary {
+    readonly exact: number;
     readonly interval: number;
     readonly unknown: number;
     readonly conditional: number;
@@ -2647,214 +3294,57 @@ interface AlignmentCohortFactSummary {
     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 flexDirection: HotNormalizedSignalEvidence;
-    readonly gridAutoFlow: 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 {
+interface EvidenceProvenance {
+    readonly reason: string;
+    readonly guardKey: string;
+    readonly guards: readonly GuardConditionProvenance[];
+}
+interface CohortProfile {
+    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 CohortSubjectStats {
     readonly element: AlignmentElementEvidence;
     readonly declaredOffset: NumericEvidenceValue;
     readonly effectiveOffset: NumericEvidenceValue;
     readonly lineHeight: NumericEvidenceValue;
-    readonly baselineProfile: AlignmentCohortProfile;
+    readonly baselineProfile: CohortProfile;
     readonly signals: AlignmentCohortSignals;
     readonly identifiability: CohortIdentifiability;
     readonly contentComposition: ContentCompositionFingerprint;
 }
-interface LayoutCohortStats {
-    readonly profile: AlignmentCohortProfile;
-    readonly snapshots: readonly LayoutSignalSnapshot[];
-    readonly factSummary: AlignmentCohortFactSummary;
+interface CohortStats {
+    readonly profile: CohortProfile;
+    readonly snapshots: readonly SignalSnapshot[];
+    readonly factSummary: CohortFactSummary;
     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 subjectsByElementKey: ReadonlyMap<string, CohortSubjectStats>;
     readonly excludedElementKeys: ReadonlySet<string>;
 }
-declare const enum ContentCompositionClassification {
-    TextOnly = 0,
-    ReplacedOnly = 1,
-    MixedUnmitigated = 2,
-    MixedMitigated = 3,
-    BlockSegmented = 4,
-    Unknown = 5
-}
+
 /**
- * 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.
+ * Stateful analysis types + computation.
+ *
+ * Moved from cross-file/layout/stateful-rule-index.ts.
  */
-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;
-}
-declare const enum EvidenceValueKind {
-    Exact = 0,
-    Interval = 1,
-    Conditional = 2,
-    Unknown = 3
-}
-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[];
-}
-
-type LayoutGuardConditionKind = "media" | "supports" | "container" | "dynamic-attribute";
-interface LayoutGuardConditionProvenance {
-    readonly kind: LayoutGuardConditionKind;
-    readonly query: string | null;
-    readonly key: string;
-}
-type LayoutRuleGuard = {
-    readonly kind: LayoutSignalGuard.Unconditional;
-    readonly conditions: readonly LayoutGuardConditionProvenance[];
-    readonly key: "always";
-} | {
-    readonly kind: LayoutSignalGuard.Conditional;
-    readonly conditions: readonly LayoutGuardConditionProvenance[];
-    readonly key: string;
-};
 
-interface LayoutCascadedDeclaration {
-    readonly value: string;
-    readonly source: LayoutSignalSource;
-    readonly guardProvenance: LayoutRuleGuard;
-}
-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 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: LayoutTextualContentState;
-    readonly isControl: boolean;
-    readonly isReplaced: boolean;
-}
-interface LayoutStyleRuleNode {
-    readonly cssFile: string;
-    readonly ruleId: number;
-    readonly selectorId: number;
-}
-interface LayoutMatchEdge {
-    readonly selectorId: number;
-    readonly specificityScore: number;
-    readonly sourceOrder: number;
-    /** Whether the selector match is conditional due to dynamic attribute values. */
-    readonly conditionalMatch: boolean;
-}
-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 hasContainIntrinsicSize: boolean;
-    readonly hasUsableAspectRatio: boolean;
-    readonly hasDeclaredInlineDimension: boolean;
-    readonly hasDeclaredBlockDimension: boolean;
-}
-declare const enum LayoutScrollAxis {
-    None = 0,
-    X = 1,
-    Y = 2,
-    Both = 3
-}
-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 {
+interface StatefulSelectorEntry {
     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 {
+interface NormalizedRuleDeclaration {
     readonly declarationId: number;
     readonly property: string;
     readonly normalizedValue: string;
@@ -2863,318 +3353,236 @@ interface LayoutNormalizedRuleDeclaration {
     readonly startColumn: number;
     readonly propertyLength: number;
 }
-interface LayoutElementRecord {
-    readonly ref: LayoutElementRef | null;
-    readonly edges: readonly LayoutMatchEdge[];
-    readonly cascade: ReadonlyMap<string, LayoutCascadedDeclaration>;
-    readonly snapshot: LayoutSignalSnapshot;
-    readonly hotSignals: LayoutSnapshotHotSignals;
-    readonly reservedSpace: LayoutReservedSpaceFact;
-    readonly scrollContainer: LayoutScrollContainerFact;
-    readonly flowParticipation: LayoutFlowParticipationFact;
-    readonly containingBlock: LayoutContainingBlockFact;
-    readonly conditionalDelta: ReadonlyMap<LayoutSignalName, LayoutConditionalSignalDeltaFact> | null;
-    readonly baselineOffsets: ReadonlyMap<LayoutSignalName, readonly number[]> | null;
-}
-interface LayoutGraph {
-    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>;
-    readonly hostElementRefsByNode: ReadonlyMap<LayoutElementNode, LayoutElementRef>;
-    readonly styleRules: readonly LayoutStyleRuleNode[];
-    readonly applies: readonly LayoutMatchEdge[];
-    readonly cssScopeBySolidFile: ReadonlyMap<string, readonly string[]>;
-    readonly selectorCandidatesByNode: ReadonlyMap<LayoutElementNode, readonly number[]>;
-    readonly selectorsById: ReadonlyMap<number, SelectorEntity>;
-    readonly records: ReadonlyMap<LayoutElementNode, LayoutElementRecord>;
-    readonly cohortStatsByParentNode: ReadonlyMap<LayoutElementNode, LayoutCohortStats>;
-    readonly contextByParentNode: ReadonlyMap<LayoutElementNode, AlignmentContext>;
-    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>>>;
-    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 a cached SolidGraph without building on miss.
-     *
-     * Returns the cached graph if the version matches, null otherwise.
-     * Use when the caller has already confirmed the entry exists via
-     * `hasSolidGraph` and wants to avoid allocating a builder closure.
-     *
-     * @param path Absolute file path
-     * @param version Script version string from the TS project service
-     */
-    getCachedSolidGraph(path: string, version: string): SolidGraph | null;
-    /**
-     * 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.
-     */
+
+interface CustomPropertyResolution {
+    readonly resolved: boolean;
+    readonly symbol: CustomPropertySymbol | null;
+    readonly value: string | null;
+    readonly unresolvedReferences: readonly VariableReferenceEntity[];
+}
+type ReactiveKind = "signal" | "props" | "store" | "resource" | "memo" | "derived";
+interface FileSemanticModel {
+    readonly filePath: string;
+    readonly compilation: StyleCompilation;
+    readonly solidTree: SolidSyntaxTree;
+    getElementNode(elementId: number): ElementNode | null;
+    getElementNodes(): readonly ElementNode[];
+    getElementCascade(elementId: number): ElementCascade;
+    getMatchingSelectors(elementId: number): readonly SelectorMatch[];
+    getComponentHost(importSource: string, exportName: string): ComponentHostSymbol | null;
+    getElementsByTagName(tag: string): readonly ElementNode[];
+    getLayoutFact<K extends LayoutFactKind>(elementId: number, factKind: K): LayoutFactMap[K];
+    getSignalSnapshot(elementId: number): SignalSnapshot;
+    getConditionalDelta(elementId: number): ReadonlyMap<string, ConditionalSignalDelta> | null;
+    getBaselineOffsets(elementId: number): ReadonlyMap<LayoutSignalName, readonly number[]> | null;
+    getClassNameInfo(name: string): ClassNameSymbol | null;
+    getCustomPropertyResolution(name: string): CustomPropertyResolution;
+    getSelectorOverrides(selectorId: number): readonly SelectorSymbol[];
+    getScopedCSSFiles(): readonly string[];
+    getScopedSelectors(): ScopedSelectorIndex;
+    getImportChain(): readonly ImportEntity[];
+    getReactiveKind(variable: VariableEntity$1): ReactiveKind | null;
+    getDependencyEdges(computation: ComputationEntity): readonly DependencyEdge[];
+    getAlignmentContext(parentElementId: number): AlignmentContext | null;
+    getCohortStats(parentElementId: number): CohortStats | null;
+    getElementsWithConditionalDelta(signal: string): readonly ElementNode[];
+    getScrollContainerElements(): readonly ElementNode[];
+    getDynamicSlotCandidates(): readonly ElementNode[];
+    getElementsByKnownSignalValue(signal: LayoutSignalName, value: string): readonly ElementNode[];
+    getStatefulSelectorEntries(ruleId: number): readonly StatefulSelectorEntry[];
+    getStatefulNormalizedDeclarations(ruleId: number): readonly NormalizedRuleDeclaration[];
+    getStatefulBaseValueIndex(): ReadonlyMap<string, ReadonlyMap<string, ReadonlySet<string>>>;
+}
+
+interface TailwindConfigInput {
+    readonly kind: "tailwind-config";
+    readonly filePath: string;
+    readonly version: string;
+    readonly validator: TailwindValidator | null;
+}
+interface PackageManifestInput {
+    readonly kind: "package-manifest";
+    readonly filePath: string;
+    readonly version: string;
+}
+interface TSConfigInput {
+    readonly kind: "tsconfig";
+    readonly filePath: string;
+    readonly version: string;
+}
+interface StyleCompilation {
+    readonly id: number;
+    readonly solidTrees: ReadonlyMap<string, SolidSyntaxTree>;
+    readonly cssTrees: ReadonlyMap<string, CSSSyntaxTree>;
+    readonly tailwindConfig: TailwindConfigInput | null;
+    readonly packageManifest: PackageManifestInput | null;
+    readonly tsConfig: TSConfigInput | null;
+    readonly symbolTable: SymbolTable;
+    readonly dependencyGraph: DependencyGraph;
+    withSolidTree(tree: SolidSyntaxTree): StyleCompilation;
+    withCSSTrees(trees: readonly CSSSyntaxTree[]): StyleCompilation;
+    withCSSTree(tree: CSSSyntaxTree): StyleCompilation;
+    withoutFile(filePath: string): StyleCompilation;
+    withTailwindConfig(config: TailwindConfigInput | null): StyleCompilation;
+    withPackageManifest(manifest: PackageManifestInput | null): StyleCompilation;
+    withTSConfig(config: TSConfigInput | null): StyleCompilation;
+    withFile(filePath: string, tree: SolidSyntaxTree | CSSSyntaxTree): StyleCompilation;
+    getSolidTree(filePath: string): SolidSyntaxTree | null;
+    getCSSTree(filePath: string): CSSSyntaxTree | null;
+    getSemanticModel(solidFilePath: string): FileSemanticModel;
+    getSolidFilePaths(): readonly string[];
+    getCSSFilePaths(): readonly string[];
+}
+declare function createStyleCompilation(): StyleCompilation;
+declare function createCompilationFromLegacy(solidTrees: readonly SolidSyntaxTree[], cssTrees: readonly CSSSyntaxTree[]): StyleCompilation;
+
+type CSSSourceProviderKind = "plain-css" | "scss" | "tailwind";
+interface CSSSymbolContribution {
+    readonly classNames: ReadonlyMap<string, CSSClassNameSource>;
+    readonly selectors: readonly SelectorSymbol[];
+    readonly declarations: readonly DeclarationSymbol[];
+    readonly customProperties: readonly CustomPropertySymbol[];
+    readonly keyframes: readonly KeyframesSymbol[];
+    readonly fontFaces: readonly FontFaceSymbol[];
+    readonly layers: readonly LayerSymbol[];
+    readonly containers: readonly ContainerSymbol[];
+    readonly themeTokens: readonly ThemeTokenSymbol[];
+}
+interface CSSSourceProvider {
+    readonly kind: CSSSourceProviderKind;
+    parse(filePath: string, content: string, sourceOrderBase: number): CSSSyntaxTree;
+    extractSymbols(tree: CSSSyntaxTree): CSSSymbolContribution;
+}
+
+type AdditionalInput = TailwindConfigInput | {
+    readonly kind: "package-manifest";
+    readonly filePath: string;
+    readonly version: string;
+} | {
+    readonly kind: "tsconfig";
+    readonly filePath: string;
+    readonly version: string;
+};
+interface CompilationTracker {
+    readonly currentCompilation: StyleCompilation;
+    readonly previousCompilation: StyleCompilation | null;
+    applyChange(filePath: string, content: string, version: string): CompilationTracker;
+    applyDeletion(filePath: string): CompilationTracker;
+    applyInputChange(input: AdditionalInput): CompilationTracker;
+    /**
+     * Apply a batch of file changes in one dependency graph rebuild.
+     * solidTrees: pre-built SolidSyntaxTrees keyed by canonical path.
+     * CSS files are parsed internally via CSSSourceProvider.
+     * Rebuilds the dependency graph ONCE after all mutations.
+     */
+    applyBatch(changes: readonly {
+        path: string;
+        content: string;
+        version: string;
+    }[], solidTrees: ReadonlyMap<string, SolidSyntaxTree>): CompilationTracker;
+    getStaleFiles(): ReadonlySet<string>;
+    getDirectlyChangedFiles(): ReadonlySet<string>;
+    isSemanticModelValid(filePath: string): boolean;
+    getCachedCrossFileDiagnostics(filePath: string): readonly Diagnostic[];
+    setCachedCrossFileDiagnostics(filePath: string, diagnostics: readonly Diagnostic[]): void;
     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;
+    invalidateCrossFileResults(): void;
+}
+interface CompilationTrackerOptions {
+    readonly cssProvider?: CSSSourceProvider;
+    readonly scssProvider?: CSSSourceProvider;
+    readonly tailwindProvider?: TailwindProvider;
+    readonly logger?: Logger;
+}
+declare function createCompilationTracker(compilation: StyleCompilation, options?: CompilationTrackerOptions): CompilationTracker;
+
+interface PlainCSSProvider extends CSSSourceProvider {
+    readonly kind: "plain-css";
+}
+declare function createPlainCSSProvider(): PlainCSSProvider;
+
+/**
+ * AnalysisRule + typed action registry — replaces CrossRule + BaseRule<CrossRuleContext>.
+ */
+
+type Emit = (diagnostic: Diagnostic) => void;
+declare const enum ComputationTier {
+    CSSSyntax = 0,
+    CrossSyntax = 1,
+    ElementResolution = 2,
+    SelectiveLayoutFacts = 3,
+    FullCascade = 4,
+    AlignmentModel = 5
+}
+interface TierRequirement {
+    readonly tier: ComputationTier;
+    readonly factKinds?: readonly LayoutFactKind[];
+    readonly signals?: readonly LayoutSignalName[];
+}
+type StyleSymbolKind = keyof StyleSymbolByKind;
+interface StyleSymbolByKind {
+    className: ClassNameSymbol;
+    selector: SelectorSymbol;
+    declaration: DeclarationSymbol;
+    customProperty: CustomPropertySymbol;
+    componentHost: ComponentHostSymbol;
+    keyframes: KeyframesSymbol;
+    fontFace: FontFaceSymbol;
+    layer: LayerSymbol;
+    container: ContainerSymbol;
+    themeToken: ThemeTokenSymbol;
+}
+interface AnalysisActionRegistry {
+    registerCSSSyntaxAction(action: (tree: CSSSyntaxTree, symbolTable: SymbolTable, emit: Emit) => void): void;
+    registerCrossSyntaxAction(action: (solidTree: SolidSyntaxTree, symbolTable: SymbolTable, emit: Emit) => void): void;
+    registerCompilationAction(action: (compilation: StyleCompilation, symbolTable: SymbolTable, emit: Emit) => void): void;
+    registerSymbolAction<K extends StyleSymbolKind>(kind: K, action: (symbol: StyleSymbolByKind[K], semanticModel: FileSemanticModel, emit: Emit) => void): void;
+    registerElementAction(action: (element: ElementNode, semanticModel: FileSemanticModel, emit: Emit) => void): void;
+    registerFactAction<K extends LayoutFactKind>(factKind: K, action: (element: ElementNode, fact: LayoutFactMap[K], semanticModel: FileSemanticModel, emit: Emit) => void): void;
+    registerCascadeAction(action: (element: ElementNode, cascade: ElementCascade, snapshot: SignalSnapshot, semanticModel: FileSemanticModel, emit: Emit) => void): void;
+    registerConditionalDeltaAction(action: (element: ElementNode, delta: ReadonlyMap<string, ConditionalSignalDelta>, semanticModel: FileSemanticModel, emit: Emit) => void): void;
+    registerAlignmentAction(action: (parentElement: ElementNode, context: AlignmentContext, cohort: CohortStats, semanticModel: FileSemanticModel, emit: Emit) => void): void;
+}
+interface AnalysisRule {
+    readonly id: string;
+    readonly severity: "error" | "warn" | "off";
+    readonly messages: Record<string, string>;
+    readonly meta: {
+        readonly description: string;
+        readonly fixable: boolean;
+        readonly category: string;
+    };
+    readonly requirement: TierRequirement;
+    register(registry: AnalysisActionRegistry): void;
 }
 
 /**
- * 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, sourceFile: ts.SourceFile, emit: Emit): void;
-/**
- * The Solid.js plugin.
- *
- * Analyzes Solid.js files by building a SolidGraph and running all rules.
- * Rules push diagnostics via the emit callback.
- */
-declare const SolidPlugin: Plugin<"solid">;
-
-declare function createSolidInput(filePath: 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
+ * AnalysisDispatcher — tiered rule execution framework.
  *
- * Predefined bundles of sizing, spacing, and contrast constraints
- * derived from WCAG 2.2, Material Design 3, Apple HIG, and
- * W3C Low Vision Needs.
+ * Like Roslyn's CompilationWithAnalyzers + AnalyzerDriver:
+ * rules register typed subscriptions, the framework inspects subscriptions
+ * to determine the maximum required tier, computes only that tier,
+ * and dispatches to subscribers.
  */
 
-/** Set the active policy for all policy rules. Pass null to disable. */
-declare function setActivePolicy(name: string | null): void;
-
-declare function buildLayoutGraph(solids: readonly SolidGraph[], css: CSSGraph, logger?: Logger): LayoutGraph;
-
-interface CrossRuleContext {
-    readonly solids: readonly SolidGraph[];
-    readonly css: CSSGraph;
-    readonly layout: LayoutGraph;
-    readonly logger: Logger;
+interface AnalysisResult {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly maxTierComputed: ComputationTier;
+}
+interface AnalysisDispatcher {
+    register(rule: AnalysisRule): void;
+    run(compilation: StyleCompilation): AnalysisResult;
+    /**
+     * Run only on a subset of affected files. Tier 0 CSS syntax actions
+     * only fire for affected CSS files. Tier 1+ only fire for affected
+     * solid files. Compilation-wide actions always run.
+     * Used for incremental re-analysis after a file change.
+     */
+    runSubset(compilation: StyleCompilation, affectedFiles: ReadonlySet<string>): AnalysisResult;
 }
+declare function createAnalysisDispatcher(): AnalysisDispatcher;
 
-/**
- * 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
- * @param log Optional logger for diagnostics
- */
-declare function runCrossFileRules(context: CrossRuleContext, emit: Emit, log?: Logger | undefined): void;
+declare const allRules: readonly AnalysisRule[];
 
-export { CSSGraph, type CSSInput, CSSPlugin, type CommentEntry, type ComputationEntity, type DependencyEdge, type Diagnostic, type Fix, type FixOperation, GraphCache, type Plugin, type ReactiveKind, type ReadEntity, type Runner, SolidGraph, type SolidInput, SolidPlugin, type TailwindValidator, type VariableEntity$1 as VariableEntity, analyzeInput, buildCSSGraph, buildLayoutGraph, buildSolidGraph, createOverrideEmit, createRunner, createSolidInput, resolveTailwindValidator, runCrossFileRules, runSolidRules, scanDependencyCustomProperties, setActivePolicy };
+export { type AnalysisDispatcher, type BatchableTailwindValidator, type CSSBuildContext, type CSSBuildResult, type CSSInput, type CSSInputBuilder, CSSPlugin, type CSSSyntaxTree, type CSSWorkspaceView, type CommentEntry, type CompilationTracker, type CompilationTrackerOptions, type ComputationEntity, type DependencyEdge, type Diagnostic, type Fix, type FixOperation, type Plugin, type ReactiveKind$1 as ReactiveKind, type ReadEntity, type Runner, type SolidBuildContext, type SolidInput, SolidPlugin, type SolidSyntaxTree, type SolidSyntaxTree as SolidTree, type StyleCompilation, type TailwindEvalParams, type TailwindValidator, type VariableEntity$1 as VariableEntity, allRules, analyzeInput, buildCSSResult, buildSolidSyntaxTree, buildTailwindValidatorFromEval, createAnalysisDispatcher, createCSSInput, createCompilationFromLegacy, createCompilationTracker, createOverrideEmit, createPlainCSSProvider, createRunner, createSolidInput, createStyleCompilation, prepareTailwindEval, resolveTailwindValidatorSync, runSolidRules, scanDependencyCustomProperties, setActivePolicy };