snoop-ui 0.0.1

package/packages/cli/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/index.ts","../src/cli/init.ts","../src/cli/scan.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { resolve } from 'node:path';\nimport { cac } from 'cac';\nimport { readFileSync } from 'node:fs';\nimport { relativePosix } from '@snoop-ui/core/utils/paths.js';\nimport { initConfig } from './init.js';\nimport { DEFAULT_MANIFEST_PATH, runScan } from './scan.js';\n\nconst pkg = JSON.parse(readFileSync(resolve(import.meta.dirname, 'package.json'), 'utf8'));\n\ninterface InitCliOptions {\n  cwd?: string;\n  force?: boolean;\n}\n\ninterface ScanCliOptions {\n  cwd?: string;\n  out?: string;\n  config?: string;\n  cache?: boolean;\n}\n\nconst cli = cac('snoop');\n\ncli\n  .command('init', 'Create a snoop.config.ts file')\n  .option('--force', 'Overwrite an existing config')\n  .option('--cwd <path>', 'Project directory')\n  .action(async (options: InitCliOptions) => {\n    const cwd = resolve(options.cwd ?? process.cwd());\n    const result = await initConfig({ cwd, force: options.force });\n    console.log(`Created ${displayPath(cwd, result.path)}.`);\n  });\n\ncli\n  .command('scan', 'Scan the project and write .snoop/manifest.json')\n  .option('--out <path>', 'Output path', { default: DEFAULT_MANIFEST_PATH })\n  .option('--cwd <path>', 'Project directory')\n  .option('--config <path>', 'Config file to load')\n  .option('--no-cache', 'Disable the content-hash scan cache')\n  .action(async (options: ScanCliOptions) => {\n    const cwd = resolve(options.cwd ?? process.cwd());\n    const { result, outPath } = await runScan({\n      cwd,\n      out: options.out,\n      ...(options.config ? { configFile: options.config } : {}),\n      cache: options.cache,\n    });\n    const { stats } = result;\n    const output = displayPath(cwd, outPath);\n\n    if (stats.components === 0) {\n      console.log(`No components found in ${stats.files} file(s).`);\n    } else {\n      console.log(`Scanned ${stats.components} component(s) in ${stats.files} file(s).`);\n    }\n\n    if (stats.cachedFiles > 0) {\n      console.log(`Reused ${stats.cachedFiles} cached file(s).`);\n    }\n\n    if (stats.errors > 0) {\n      console.log(`${stats.errors} file(s) had warnings; see ${output}.`);\n    }\n\n    console.log(`Wrote ${output}.`);\n  });\n\ncli.help();\ncli.version(pkg.version);\n\nasync function main(): Promise<void> {\n  if (process.argv.slice(2).length === 0) {\n    cli.outputHelp();\n    return;\n  }\n\n  const wantsHelp = process.argv.includes('--help') || process.argv.includes('-h');\n  const wantsVersion = process.argv.includes('--version') || process.argv.includes('-v');\n\n  cli.parse(process.argv, { run: false });\n\n  if (!cli.matchedCommand) {\n    if (!wantsHelp && !wantsVersion && cli.args[0]) {\n      console.error(`Unknown command: ${cli.args[0]}`);\n      cli.outputHelp();\n      process.exitCode = 1;\n    }\n    return;\n  }\n\n  try {\n    await cli.runMatchedCommand();\n  } catch (error) {\n    console.error(error instanceof Error ? error.message : String(error));\n    process.exitCode = 1;\n  }\n}\n\nfunction displayPath(cwd: string, path: string): string {\n  return relativePosix(cwd, path) || '.';\n}\n\nawait main();\n","import { access, writeFile } from 'node:fs/promises';\nimport { resolve } from 'node:path';\n\nexport interface InitOptions {\n  cwd?: string;\n  force?: boolean;\n}\n\nexport interface InitResult {\n  path: string;\n}\n\nconst CONFIG_TEMPLATE = `import { defineConfig } from 'snoop-ui';\n\nexport default defineConfig({\n  // include: ['src/**/*.{jsx,tsx}'],\n  // exclude: ['**/*.stories.{js,jsx,ts,tsx}'],\n  // tokens: ['src/styles/tokens.css'],\n});\n`;\n\nexport async function initConfig(options: InitOptions = {}): Promise<InitResult> {\n  const cwd = resolve(options.cwd ?? process.cwd());\n  const path = resolve(cwd, 'snoop.config.ts');\n\n  if (!options.force && (await exists(path))) {\n    throw new Error(`A Snoop config already exists at ${path}. Use --force to overwrite it.`);\n  }\n\n  try {\n    await writeFile(path, CONFIG_TEMPLATE, {\n      encoding: 'utf8',\n      flag: options.force ? 'w' : 'wx',\n    });\n  } catch (error) {\n    if (!options.force && isAlreadyExists(error)) {\n      throw new Error(`A Snoop config already exists at ${path}. Use --force to overwrite it.`, {\n        cause: error,\n      });\n    }\n    throw error;\n  }\n\n  return { path };\n}\n\nasync function exists(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction isAlreadyExists(error: unknown): boolean {\n  return typeof error === 'object' && error !== null && 'code' in error && error.code === 'EEXIST';\n}\n","import { resolve } from 'node:path';\nimport { loadConfig } from '@snoop-ui/core/config.js';\nimport { scanProject, writeManifest, type ScanResult } from '@snoop-ui/core/scanner/index.js';\n\nexport interface ScanOptions {\n  cwd?: string;\n  out?: string;\n  configFile?: string;\n  cache?: boolean;\n}\n\nexport interface ScanCommandResult {\n  result: ScanResult;\n  outPath: string;\n}\n\nexport const DEFAULT_MANIFEST_PATH = '.snoop/manifest.json';\n\nexport async function runScan(options: ScanOptions = {}): Promise<ScanCommandResult> {\n  const cwd = resolve(options.cwd ?? process.cwd());\n  const config = await loadConfig({\n    cwd,\n    ...(options.configFile ? { configFile: options.configFile } : {}),\n  });\n\n  const result = await scanProject({\n    cwd,\n    include: config.include,\n    exclude: config.exclude,\n    tokens: config.tokens,\n    cache: options.cache,\n  });\n\n  const outPath = resolve(cwd, options.out ?? DEFAULT_MANIFEST_PATH);\n  await writeManifest(outPath, result.manifest);\n\n  return { result, outPath };\n}\n"],"mappings":"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","names":["resolve","resolve","resolve"]}

package/packages/core/dist/index.d.ts

@@ -0,0 +1,607 @@
+import { z } from 'zod';
+
+declare const RuleSettingSchema: z.ZodEnum<{
+    off: "off";
+    info: "info";
+    warning: "warning";
+    error: "error";
+}>;
+type RuleSetting = z.infer<typeof RuleSettingSchema>;
+declare const DEFAULT_INCLUDE: readonly ["src/**/*.{jsx,tsx}"];
+declare const DEFAULT_EXCLUDE: readonly ["**/node_modules/**", "**/dist/**", "**/build/**", "**/*.test.{js,jsx,ts,tsx}", "**/*.spec.{js,jsx,ts,tsx}", "**/*.stories.{js,jsx,ts,tsx}"];
+declare const ConfigSchema: z.ZodObject<{
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tokens: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    providers: z.ZodOptional<z.ZodString>;
+    tolerance: z.ZodDefault<z.ZodObject<{
+        px: z.ZodNumber;
+    }, z.core.$strip>>;
+    baseline: z.ZodDefault<z.ZodString>;
+    basePath: z.ZodDefault<z.ZodString>;
+    appUrl: z.ZodDefault<z.ZodString>;
+    rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        off: "off";
+        info: "info";
+        warning: "warning";
+        error: "error";
+    }>>>;
+    editor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SnoopConfig = z.input<typeof ConfigSchema>;
+type ResolvedConfig = z.output<typeof ConfigSchema>;
+
+interface LoadConfigOptions {
+    cwd?: string;
+    configFile?: string;
+}
+declare function defineConfig(config: SnoopConfig): SnoopConfig;
+declare function findConfigFile(options?: LoadConfigOptions): Promise<string | undefined>;
+declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedConfig>;
+
+declare const PropSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Prop = z.infer<typeof PropSchema>;
+declare const ComponentNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"component">;
+    name: z.ZodString;
+    file: z.ZodString;
+    exportName: z.ZodOptional<z.ZodString>;
+    loc: z.ZodOptional<z.ZodObject<{
+        start: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+        end: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    props: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        defaultValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ComponentNode = z.infer<typeof ComponentNodeSchema>;
+declare const EdgeRelationSchema: z.ZodEnum<{
+    renders: "renders";
+    imports: "imports";
+}>;
+type EdgeRelation = z.infer<typeof EdgeRelationSchema>;
+declare const EdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    relation: z.ZodEnum<{
+        renders: "renders";
+        imports: "imports";
+    }>;
+    confidence: z.ZodEnum<{
+        EXTRACTED: "EXTRACTED";
+        INFERRED: "INFERRED";
+    }>;
+}, z.core.$strip>;
+type Edge = z.infer<typeof EdgeSchema>;
+declare const ScanErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    file: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+type ScanError = z.infer<typeof ScanErrorSchema>;
+declare const TokenTableSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+type TokenTable = z.infer<typeof TokenTableSchema>;
+declare const ManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    tokens: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"component">;
+        name: z.ZodString;
+        file: z.ZodString;
+        exportName: z.ZodOptional<z.ZodString>;
+        loc: z.ZodOptional<z.ZodObject<{
+            start: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+            end: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        props: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            defaultValue: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        relation: z.ZodEnum<{
+            renders: "renders";
+            imports: "imports";
+        }>;
+        confidence: z.ZodEnum<{
+            EXTRACTED: "EXTRACTED";
+            INFERRED: "INFERRED";
+        }>;
+    }, z.core.$strip>>>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        file: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+/**
+ * Produce deterministic manifest output for golden tests, CI diffs, and
+ * reproducible `snoop scan` results.
+ */
+declare function sortManifest(manifest: Manifest): Manifest;
+
+declare const StyleDeclarationSchema: z.ZodObject<{
+    property: z.ZodString;
+    value: z.ZodString;
+    important: z.ZodDefault<z.ZodBoolean>;
+    line: z.ZodNumber;
+    col: z.ZodNumber;
+}, z.core.$strip>;
+type StyleDeclaration = z.infer<typeof StyleDeclarationSchema>;
+declare const StyleRuleSchema: z.ZodObject<{
+    file: z.ZodString;
+    selector: z.ZodString;
+    runtimeSelector: z.ZodOptional<z.ZodString>;
+    declarations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        property: z.ZodString;
+        value: z.ZodString;
+        important: z.ZodDefault<z.ZodBoolean>;
+        line: z.ZodNumber;
+        col: z.ZodNumber;
+    }, z.core.$strip>>>;
+    atRules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    module: z.ZodDefault<z.ZodBoolean>;
+    line: z.ZodNumber;
+    col: z.ZodNumber;
+}, z.core.$strip>;
+type StyleRule = z.infer<typeof StyleRuleSchema>;
+declare const InlineStyleSchema: z.ZodObject<{
+    src: z.ZodString;
+    file: z.ZodString;
+    range: z.ZodObject<{
+        start: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+        end: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    confidence: z.ZodEnum<{
+        EXTRACTED: "EXTRACTED";
+        INFERRED: "INFERRED";
+    }>;
+}, z.core.$strip>;
+type InlineStyle = z.infer<typeof InlineStyleSchema>;
+declare const StyleErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    file: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+type StyleError = z.infer<typeof StyleErrorSchema>;
+/**
+ * Static style knowledge served alongside the manifest. It is not part of the
+ * manifest artifact: the browser CSSOM remains the source of truth for values,
+ * and this index only supplies file/line provenance and tokens.
+ */
+declare const StyleIndexSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    tokens: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        selector: z.ZodString;
+        runtimeSelector: z.ZodOptional<z.ZodString>;
+        declarations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            property: z.ZodString;
+            value: z.ZodString;
+            important: z.ZodDefault<z.ZodBoolean>;
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>>>;
+        atRules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        module: z.ZodDefault<z.ZodBoolean>;
+        line: z.ZodNumber;
+        col: z.ZodNumber;
+    }, z.core.$strip>>>;
+    inlineStyles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        src: z.ZodString;
+        file: z.ZodString;
+        range: z.ZodObject<{
+            start: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+            end: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        confidence: z.ZodEnum<{
+            EXTRACTED: "EXTRACTED";
+            INFERRED: "INFERRED";
+        }>;
+    }, z.core.$strip>>>;
+    tailwind: z.ZodDefault<z.ZodBoolean>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        file: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type StyleIndex = z.infer<typeof StyleIndexSchema>;
+declare function sortStyleIndex(index: StyleIndex): StyleIndex;
+
+declare const SeveritySchema: z.ZodEnum<{
+    info: "info";
+    warning: "warning";
+    error: "error";
+}>;
+type Severity = z.infer<typeof SeveritySchema>;
+declare const DiagnosticFixSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"replace">;
+    text: z.ZodString;
+}, z.core.$strip>;
+type DiagnosticFix = z.infer<typeof DiagnosticFixSchema>;
+declare const DiagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        error: "error";
+    }>;
+    confidence: z.ZodEnum<{
+        EXTRACTED: "EXTRACTED";
+        INFERRED: "INFERRED";
+    }>;
+    file: z.ZodString;
+    range: z.ZodObject<{
+        start: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+        end: z.ZodObject<{
+            line: z.ZodNumber;
+            col: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    message: z.ZodString;
+    fix: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"replace">;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    fingerprint: z.ZodString;
+}, z.core.$strip>;
+type Diagnostic = z.infer<typeof DiagnosticSchema>;
+declare const DiagnosticsFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+        confidence: z.ZodEnum<{
+            EXTRACTED: "EXTRACTED";
+            INFERRED: "INFERRED";
+        }>;
+        file: z.ZodString;
+        range: z.ZodObject<{
+            start: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+            end: z.ZodObject<{
+                line: z.ZodNumber;
+                col: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        message: z.ZodString;
+        fix: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"replace">;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type DiagnosticsFile = z.infer<typeof DiagnosticsFileSchema>;
+declare function sortDiagnostics(file: DiagnosticsFile): DiagnosticsFile;
+
+interface ScanProjectOptions {
+    cwd?: string;
+    include?: string[];
+    exclude?: string[];
+    /** Extra CSS token files from `snoop.config.ts`. */
+    tokens?: string[];
+    /** Cache parsed files by content hash. Enabled by default. */
+    cache?: boolean;
+    /** Resolve Vite CSS Modules class names. The dev plugin supplies this. */
+    resolveCssModules?: (files: string[]) => Promise<Record<string, Record<string, string>>>;
+}
+interface ScanStats {
+    files: number;
+    parsedFiles: number;
+    cachedFiles: number;
+    components: number;
+    edges: number;
+    errors: number;
+}
+interface ScanResult {
+    manifest: Manifest;
+    styles: StyleIndex;
+    diagnostics: DiagnosticsFile;
+    stats: ScanStats;
+}
+/**
+ * Scan a project and return a deterministic manifest. Failures are per file:
+ * a broken file becomes an entry in `manifest.errors` and never stops the scan.
+ */
+declare function scanProject(options?: ScanProjectOptions): Promise<ScanResult>;
+declare function writeManifest(outPath: string, manifest: Manifest): Promise<void>;
+
+declare const ConfidenceSchema: z.ZodEnum<{
+    EXTRACTED: "EXTRACTED";
+    INFERRED: "INFERRED";
+}>;
+type Confidence = z.infer<typeof ConfidenceSchema>;
+declare const PositionSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    col: z.ZodNumber;
+}, z.core.$strip>;
+type Position = z.infer<typeof PositionSchema>;
+declare const RangeSchema: z.ZodObject<{
+    start: z.ZodObject<{
+        line: z.ZodNumber;
+        col: z.ZodNumber;
+    }, z.core.$strip>;
+    end: z.ZodObject<{
+        line: z.ZodNumber;
+        col: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type SourceRange = z.infer<typeof RangeSchema>;
+declare const PosixPathSchema: z.ZodString;
+type PosixPath = z.infer<typeof PosixPathSchema>;
+declare function compareStrings(a: string, b: string): number;
+
+declare const MANIFEST_VERSION: 1;
+declare const DIAGNOSTICS_VERSION: 1;
+declare const STYLE_INDEX_VERSION: 1;
+
+interface ParseStyleSheetOptions {
+    /** Generated class name -> original class name, from Vite's CSS Modules output. */
+    classMap?: Record<string, string>;
+}
+interface ParsedStyleSheet {
+    rules: StyleRule[];
+    /** CSS custom properties found in the sheet, including `@theme` values. */
+    tokens: Record<string, string>;
+    /** The sheet references Tailwind (`@tailwind` or `@import "tailwindcss"`). */
+    tailwind: boolean;
+    /** The sheet declares a Tailwind v4 `@theme` block. */
+    theme: boolean;
+}
+/**
+ * Parse one stylesheet into the static style index. The browser CSSOM remains
+ * the source of truth for computed values; this only records where a rule and
+ * its declarations live in source.
+ */
+declare function parseStyleSheet(file: string, source: string, options?: ParseStyleSheetOptions): ParsedStyleSheet;
+/** Rename classes in a selector using Vite's generated CSS Modules names. */
+declare function rewriteClasses(selector: string, classMap: Record<string, string>): string;
+
+/**
+ * Wire protocol shared by the dashboard, the runtime agent, and the dev-server
+ * bridge.
+ *
+ * The bridge is a relay: dashboard messages travel to agents, agent messages
+ * travel to dashboards. The server never interprets the payload, so both sides
+ * can evolve without changing the server.
+ */
+type BridgeRole = 'agent' | 'dashboard';
+declare const AGENT_ROLE: BridgeRole;
+declare const DASHBOARD_ROLE: BridgeRole;
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+}
+interface MeasuredElement {
+    /** `file:line:col` taken from the `data-snoop-src` attribute. */
+    src: string;
+    tag: string;
+    rect: Rect;
+}
+interface MatchedDeclaration {
+    property: string;
+    /** The declaration as written, before the browser resolves variables. */
+    value: string;
+    important: boolean;
+}
+interface MatchedRule {
+    /** Selector text from the browser CSSOM. */
+    selector: string;
+    declarations: MatchedDeclaration[];
+    /** Source order across the document's stylesheets. */
+    order: number;
+    /** Enclosing conditional at-rules, outermost first. */
+    atRules: string[];
+}
+interface ElementDetail {
+    src: string;
+    tag: string;
+    rect: Rect;
+    /** Curated computed-style values for the selected element only. */
+    style: Record<string, string>;
+    /** Class names currently on the element. */
+    classes: string[];
+    /** Inline declarations, limited to the curated style properties. */
+    inlineStyle: Record<string, string>;
+    /** Stylesheet rules that match the element, in document order. */
+    matchedRules: MatchedRule[];
+}
+/** Messages sent by the runtime agent to the dashboard. */
+type AgentMessage = {
+    kind: 'ready';
+} | {
+    kind: 'presence';
+    connected: boolean;
+} | {
+    kind: 'elements';
+    elements: MeasuredElement[];
+} | {
+    kind: 'detail';
+    detail: ElementDetail;
+} | {
+    kind: 'click';
+    src: string;
+} | {
+    kind: 'hover';
+    src: string | null;
+};
+/** Messages sent by the dashboard to the runtime agent. */
+type DashboardMessage = {
+    kind: 'measure';
+    enabled: boolean;
+} | {
+    kind: 'inspect';
+    enabled: boolean;
+} | {
+    kind: 'isolate';
+    enabled: boolean;
+} | {
+    kind: 'select';
+    srcs: string[];
+    /** Scroll the first source to the centre of the viewport. */
+    reveal?: boolean;
+} | {
+    kind: 'sync';
+};
+type RelayPayload = AgentMessage | DashboardMessage;
+interface RelayEnvelope {
+    type: 'relay';
+    payload: RelayPayload;
+}
+declare function isAgentMessage(value: unknown): value is AgentMessage;
+declare function isDashboardMessage(value: unknown): value is DashboardMessage;
+declare function isRelayEnvelope(value: unknown): value is RelayEnvelope;
+declare function parseRole(value: string | null | undefined): BridgeRole;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+
+type StyleSourceKind = 'inline' | 'stylesheet' | 'css-module' | 'tailwind' | 'unknown';
+interface StyleSource {
+    kind: StyleSourceKind;
+    confidence: Confidence;
+    file?: string;
+    line?: number;
+    col?: number;
+    selector?: string;
+    atRules?: string[];
+    /** Number of static rules that matched the same selector and property. */
+    candidates?: number;
+}
+type StyleProvenance = Record<string, StyleSource>;
+interface StyleIndexer {
+    resolve(detail: ElementDetail): StyleProvenance;
+}
+/**
+ * Combine the browser's matched rules with the static CSS index. The browser
+ * decides the winning declaration; the index says where that declaration was
+ * written. Ambiguity is reported as INFERRED instead of guessed.
+ */
+declare function createStyleIndexer(index: StyleIndex): StyleIndexer;
+
+interface ScanStylesOptions {
+    cwd?: string;
+    /** Extra token files from `snoop.config.ts`; read even outside `src`. */
+    tokenFiles?: readonly string[];
+    exclude?: readonly string[];
+    /** Inline `style` props found by the component scanner. */
+    inlineStyles?: readonly InlineStyle[];
+    /**
+     * Resolve Vite's CSS Modules class names for module files. The plugin
+     * supplies this; the CLI leaves it out and keeps original selectors.
+     */
+    resolveCssModules?: (files: string[]) => Promise<Record<string, Record<string, string>>>;
+}
+/** Scan CSS and build the static half of style provenance. */
+declare function scanStyles(options?: ScanStylesOptions): Promise<StyleIndex>;
+
+/**
+ * Selector helpers shared by the static CSS parser and the dashboard. They are
+ * deliberately dependency-free so they can run in the browser dashboard and in
+ * the Node tests without pulling PostCSS into the client bundle.
+ */
+interface Specificity {
+    id: number;
+    class: number;
+    type: number;
+}
+/**
+ * Normalize a selector list for lookup. Whitespace and spaces around
+ * combinators are insignificant, but the contents of strings, attribute
+ * selectors, and pseudo-class arguments are preserved.
+ */
+declare function normalizeSelector(selector: string): string;
+/**
+ * Compute selector specificity with a small, dependency-free parser. The
+ * cascade only needs the values to be ordered correctly; this follows the
+ * Selectors Level 4 rules for `:is`, `:not`, `:has`, `:where`, and
+ * `:nth-child(… of …)`.
+ */
+declare function specificityOf(selector: string): Specificity;
+declare function compareSpecificity(a: Specificity, b: Specificity): number;
+
+interface TailwindThemeResult {
+    tokens: Record<string, string>;
+    found: boolean;
+    errors: StyleError[];
+}
+/**
+ * Read Tailwind v3 theme values through Tailwind's own `resolveConfig` and keep
+ * only values the project changed from the default theme. Tailwind v4 values
+ * arrive as CSS custom properties from `@theme` and are collected by the CSS
+ * parser instead.
+ */
+declare function extractTailwindTheme(cwd: string): Promise<TailwindThemeResult>;
+
+type RuleName = 'token/hardcoded-match' | 'token/near-match' | 'token/undefined-var';
+interface RuleContext {
+    manifest: Manifest;
+    styleIndex: StyleIndex;
+    config: ResolvedConfig;
+}
+interface RuleResult {
+    diagnostics: Diagnostic[];
+}
+type Rule = (context: RuleContext) => RuleResult;
+declare const RULE_NAMES: RuleName[];
+declare function createRulesEngine(context: RuleContext, enabled?: Partial<Record<RuleName, boolean>>): RuleResult;
+
+declare const VERSION: string;
+
+export { AGENT_ROLE, ComponentNodeSchema, ConfidenceSchema, ConfigSchema, DASHBOARD_ROLE, DEFAULT_EXCLUDE, DEFAULT_INCLUDE, DIAGNOSTICS_VERSION, DiagnosticFixSchema, DiagnosticSchema, DiagnosticsFileSchema, EdgeRelationSchema, EdgeSchema, InlineStyleSchema, MANIFEST_VERSION, ManifestSchema, PositionSchema, PosixPathSchema, PropSchema, RULE_NAMES, RangeSchema, RuleSettingSchema, STYLE_INDEX_VERSION, ScanErrorSchema, SeveritySchema, StyleDeclarationSchema, StyleErrorSchema, StyleIndexSchema, StyleRuleSchema, TokenTableSchema, VERSION, compareSpecificity, compareStrings, createRulesEngine, createStyleIndexer, defineConfig, extractTailwindTheme, findConfigFile, isAgentMessage, isDashboardMessage, isRecord, isRelayEnvelope, loadConfig, normalizeSelector, parseRole, parseStyleSheet, rewriteClasses, scanProject, scanStyles, sortDiagnostics, sortManifest, sortStyleIndex, specificityOf, writeManifest };
+export type { AgentMessage, BridgeRole, ComponentNode, Confidence, DashboardMessage, Diagnostic, DiagnosticFix, DiagnosticsFile, Edge, EdgeRelation, ElementDetail, InlineStyle, Manifest, MatchedDeclaration, MatchedRule, MeasuredElement, ParsedStyleSheet, Position, PosixPath, Prop, Rect, RelayEnvelope, RelayPayload, ResolvedConfig, Rule, RuleContext, RuleName, RuleResult, RuleSetting, ScanError, ScanProjectOptions, ScanResult, ScanStats, ScanStylesOptions, Severity, SnoopConfig, SourceRange, Specificity, StyleDeclaration, StyleError, StyleIndex, StyleIndexer, StyleProvenance, StyleRule, StyleSource, StyleSourceKind, TailwindThemeResult, TokenTable };