snoop-ui 0.0.1

package/packages/core/dist/index.js

@@ -0,0 +1,2421 @@
+// package.json
+var package_default = {
+  name: "@snoop-ui/core",
+  version: "0.0.1",
+  private: true,
+  license: "MIT",
+  type: "module",
+  description: "Snoop core: scanner, styles, rules, schemas, protocols",
+  main: "dist/index.js",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./schemas/*": "./schemas/*"
+  },
+  files: [
+    "dist",
+    "schemas"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    schemas: "node scripts/generate-schemas.mjs",
+    "bundle:size": "node scripts/check-bundle-size.mjs",
+    "docs:links": "node scripts/check-docs-links.mjs",
+    "licenses:check": "node scripts/check-licenses.mjs"
+  },
+  dependencies: {
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.28.5",
+    cac: "^7.1.0",
+    jiti: "^2.7.0",
+    postcss: "^8.5.32",
+    "postcss-selector-parser": "^7.2.0",
+    "postcss-value-parser": "^4.2.0",
+    "react-docgen": "^8.0.4",
+    "react-docgen-typescript": "^2.4.0",
+    tinyglobby: "^0.2.17",
+    ws: "^8.22.2",
+    zod: "^4.6.7"
+  },
+  peerDependencies: {
+    react: "^18.3.0 || ^19.0.0",
+    "react-dom": "^18.3.0 || ^19.0.0",
+    tailwindcss: "^3.4.0 || ^4.0.0",
+    vite: "^7.0.0 || ^8.0.0"
+  },
+  peerDependenciesMeta: {
+    tailwindcss: {
+      optional: true
+    },
+    vite: {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@babel/core": "^7.28.5",
+    "@types/babel__traverse": "7.28.0",
+    "@types/node": "^22.20.5",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@types/ws": "^8.18.2",
+    eslint: "^10.14.0",
+    prettier: "^3.10.0",
+    react: "^19.3.1",
+    "react-dom": "^19.3.1",
+    tsup: "^9.0.0",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.72.2",
+    vitest: "^5.1.0"
+  }
+};
+
+// src/config.ts
+import { access } from "fs/promises";
+import { resolve } from "path";
+import { createJiti } from "jiti";
+
+// src/schema/config.ts
+import { z } from "zod";
+var RuleSettingSchema = z.enum(["off", "info", "warning", "error"]);
+var DEFAULT_INCLUDE = ["src/**/*.{jsx,tsx}"];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/*.test.{js,jsx,ts,tsx}",
+  "**/*.spec.{js,jsx,ts,tsx}",
+  "**/*.stories.{js,jsx,ts,tsx}"
+];
+var ConfigSchema = z.object({
+  include: z.array(z.string()).default([...DEFAULT_INCLUDE]),
+  exclude: z.array(z.string()).default([...DEFAULT_EXCLUDE]),
+  tokens: z.array(z.string()).default([]),
+  /**
+   * Reserved for isolated previews. Not used by the zero-config MVP.
+   */
+  providers: z.string().optional(),
+  tolerance: z.object({
+    px: z.number().nonnegative()
+  }).default({ px: 1 }),
+  baseline: z.string().default(".snoop/baseline.json"),
+  basePath: z.string().startsWith("/").default("/ui"),
+  appUrl: z.string().default("/"),
+  rules: z.record(z.string(), RuleSettingSchema).default({}),
+  editor: z.string().optional()
+});
+
+// src/config.ts
+var CONFIG_FILES = [
+  "snoop.config.ts",
+  "snoop.config.mts",
+  "snoop.config.js",
+  "snoop.config.mjs",
+  "snoop.config.cjs"
+];
+function defineConfig(config) {
+  return config;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findConfigFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.configFile) {
+    const candidate = resolve(cwd, options.configFile);
+    if (!await exists(candidate)) {
+      throw new Error(`Snoop config not found: ${candidate}`);
+    }
+    return candidate;
+  }
+  for (const name of CONFIG_FILES) {
+    const candidate = resolve(cwd, name);
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+async function loadConfig(options = {}) {
+  const configFile = await findConfigFile(options);
+  if (!configFile) {
+    return ConfigSchema.parse({});
+  }
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  let loaded;
+  try {
+    loaded = await jiti.import(configFile);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load Snoop config at ${configFile}: ${message}`, {
+      cause: error
+    });
+  }
+  const raw = isRecord(loaded) && "default" in loaded ? loaded.default : loaded;
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const details = result.error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+    throw new Error(`Invalid Snoop config at ${configFile}:
+${details}`);
+  }
+  return result.data;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/scanner/analyze.ts
+import { parse as parseSource } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import { ERROR_CODES, builtinResolvers, parse as parseComponents } from "react-docgen";
+
+// src/utils/paths.ts
+import { relative, sep } from "path";
+function toPosixPath(value) {
+  return value.split(sep).join("/");
+}
+function relativePosix(from, to) {
+  return toPosixPath(relative(from, to));
+}
+function sanitizeMessage(message, cwd) {
+  const firstLine = message.split("\n")[0] ?? message;
+  return firstLine.split(cwd).join(".").split("\\").join("/");
+}
+
+// src/scanner/analyze.ts
+var traverse = typeof traverseModule === "function" ? traverseModule : traverseModule.default;
+var COMPONENT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+function analyzeFile(options) {
+  const { absolutePath, cwd, file, hash, source } = options;
+  const extension = absolutePath.slice(absolutePath.lastIndexOf("."));
+  let ast;
+  try {
+    ast = parseSource(source, {
+      sourceType: "unambiguous",
+      plugins: parserPlugins(extension),
+      attachComment: false,
+      errorRecovery: false
+    });
+  } catch (error) {
+    return {
+      error: {
+        code: "parse/syntax",
+        file,
+        message: sanitizeMessage(
+          error instanceof Error ? error.message : "Unknown syntax error",
+          cwd
+        )
+      }
+    };
+  }
+  const moduleInfo = collectModuleInfo(ast.program.body);
+  const imports = collectImports(ast.program.body);
+  const usages = collectJsxUsages(ast);
+  const inlineStyles = collectInlineStyles(ast, file);
+  let docs = [];
+  let docgenError;
+  try {
+    docs = parseComponents(source, {
+      filename: absolutePath,
+      babelOptions: {
+        filename: absolutePath,
+        babelrc: false,
+        configFile: false
+      },
+      resolver: new builtinResolvers.FindExportedDefinitionsResolver()
+    });
+  } catch (error) {
+    if (!isMissingDefinition(error)) {
+      docgenError = {
+        code: "parse/components",
+        file,
+        message: sanitizeMessage(
+          error instanceof Error ? error.message : "Could not extract component metadata",
+          cwd
+        )
+      };
+    }
+  }
+  const components = buildComponents(docs, moduleInfo);
+  return {
+    analysis: {
+      file,
+      hash,
+      components,
+      imports,
+      usages,
+      inlineStyles
+    },
+    ...docgenError ? { error: docgenError } : {}
+  };
+}
+function parserPlugins(extension) {
+  const plugins = ["jsx", "decorators-legacy", "importAttributes"];
+  if (COMPONENT_EXTENSIONS.has(extension) && extension !== ".js" && extension !== ".jsx") {
+    plugins.push("typescript");
+  }
+  return plugins;
+}
+function collectModuleInfo(body) {
+  const declarations = /* @__PURE__ */ new Map();
+  const exportsByLocal = /* @__PURE__ */ new Map();
+  const addExport = (localName, exportName) => {
+    const names = exportsByLocal.get(localName) ?? /* @__PURE__ */ new Set();
+    names.add(exportName);
+    exportsByLocal.set(localName, names);
+  };
+  const addDeclaration = (name, node) => {
+    const loc = sourceRange(node);
+    if (!loc) {
+      return;
+    }
+    if (!declarations.has(name)) {
+      declarations.set(name, {
+        name,
+        node,
+        start: node.start ?? 0,
+        end: node.end ?? 0,
+        loc
+      });
+    }
+  };
+  const addVariableDeclaration = (node, exported) => {
+    for (const declarator of node.declarations) {
+      if (declarator.id.type !== "Identifier") {
+        continue;
+      }
+      addDeclaration(declarator.id.name, declarator);
+      if (exported) {
+        addExport(declarator.id.name, declarator.id.name);
+      }
+    }
+  };
+  let defaultDeclaration;
+  for (const statement of body) {
+    switch (statement.type) {
+      case "ExportNamedDeclaration": {
+        if (statement.exportKind === "type") {
+          break;
+        }
+        const declaration = statement.declaration;
+        switch (declaration?.type) {
+          case "FunctionDeclaration":
+          case "ClassDeclaration":
+            if (declaration.id) {
+              addDeclaration(declaration.id.name, declaration);
+              addExport(declaration.id.name, declaration.id.name);
+            }
+            break;
+          case "VariableDeclaration":
+            addVariableDeclaration(declaration, true);
+            break;
+          default:
+            break;
+        }
+        for (const specifier of statement.specifiers) {
+          if (specifier.type !== "ExportSpecifier" || specifier.exportKind === "type") {
+            continue;
+          }
+          const localName = identifierName(specifier.local);
+          const exportName = specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
+          if (localName) {
+            addExport(localName, exportName);
+          }
+        }
+        break;
+      }
+      case "ExportDefaultDeclaration": {
+        const declaration = statement.declaration;
+        const loc = sourceRange(declaration);
+        if (!loc) {
+          break;
+        }
+        const name = declarationName(declaration);
+        defaultDeclaration = {
+          name: name ?? "DefaultExport",
+          node: declaration,
+          start: declaration.start ?? 0,
+          end: declaration.end ?? 0,
+          loc
+        };
+        if (name) {
+          addExport(name, "default");
+        }
+        if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id) {
+          addDeclaration(declaration.id.name, declaration);
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+      case "ClassDeclaration":
+        if (statement.id) {
+          addDeclaration(statement.id.name, statement);
+        }
+        break;
+      case "VariableDeclaration":
+        addVariableDeclaration(statement, false);
+        break;
+      default:
+        break;
+    }
+  }
+  return {
+    declarations,
+    exportsByLocal,
+    ...defaultDeclaration ? { defaultDeclaration } : {}
+  };
+}
+function collectImports(body) {
+  const imports = [];
+  for (const statement of body) {
+    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") {
+      continue;
+    }
+    const source = statement.source.value;
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") {
+        continue;
+      }
+      switch (specifier.type) {
+        case "ImportDefaultSpecifier":
+          imports.push({ source, imported: "default", local: specifier.local.name });
+          break;
+        case "ImportNamespaceSpecifier":
+          imports.push({ source, imported: "*", local: specifier.local.name });
+          break;
+        case "ImportSpecifier": {
+          const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+          imports.push({ source, imported, local: specifier.local.name });
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return imports.sort((a, b) => compare(a.local, b.local));
+}
+function collectInlineStyles(ast, file) {
+  const inlineStyles = [];
+  traverse(ast, {
+    JSXOpeningElement(path) {
+      const name = path.node.name;
+      if (name.type !== "JSXIdentifier" || !isIntrinsicName(name.name)) {
+        return;
+      }
+      const attribute = path.node.attributes.find(
+        (candidate) => candidate.type === "JSXAttribute" && candidate.name.type === "JSXIdentifier" && candidate.name.name === "style"
+      );
+      if (!attribute) {
+        return;
+      }
+      const range = sourceRange(attribute);
+      const line = name.loc?.start.line;
+      const col = name.loc ? name.loc.start.column + 1 : 0;
+      if (!range || !line || col < 1) {
+        return;
+      }
+      inlineStyles.push({
+        src: `${file}:${line}:${col}`,
+        file,
+        range,
+        confidence: isStaticStyleObject(attribute) ? "EXTRACTED" : "INFERRED"
+      });
+    }
+  });
+  return inlineStyles.sort((a, b) => compare(a.src, b.src));
+}
+function isStaticStyleObject(attribute) {
+  const value = attribute.value;
+  if (value?.type !== "JSXExpressionContainer") {
+    return false;
+  }
+  const expression = value.expression;
+  return expression.type === "ObjectExpression" && !expression.properties.some((property) => property.type === "SpreadElement");
+}
+function isIntrinsicName(name) {
+  const first = name.charAt(0);
+  return first === first.toLowerCase() && first !== first.toUpperCase();
+}
+function collectJsxUsages(ast) {
+  const usages = [];
+  traverse(ast, {
+    JSXOpeningElement(path) {
+      const name = jsxName(path.node.name);
+      if (!name) {
+        return;
+      }
+      const loc = sourceRange(path.node);
+      if (!loc) {
+        return;
+      }
+      usages.push({
+        local: name.local,
+        ...name.member ? { member: name.member } : {},
+        start: path.node.start ?? 0,
+        loc
+      });
+    }
+  });
+  return usages.sort((a, b) => a.start - b.start || compare(a.local, b.local));
+}
+function buildComponents(docs, moduleInfo) {
+  const matched = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const doc of docs) {
+    const displayName = typeof doc.displayName === "string" ? doc.displayName : void 0;
+    let declaration = displayName ? moduleInfo.declarations.get(displayName) : void 0;
+    if (!declaration && moduleInfo.defaultDeclaration) {
+      if (!displayName || docs.length === 1 || moduleInfo.defaultDeclaration.name === displayName) {
+        declaration = moduleInfo.defaultDeclaration;
+      }
+    }
+    if (!declaration) {
+      continue;
+    }
+    const exportNames = new Set(moduleInfo.exportsByLocal.get(declaration.name) ?? []);
+    if (moduleInfo.defaultDeclaration?.node === declaration.node) {
+      exportNames.add("default");
+    }
+    if (exportNames.size === 0) {
+      continue;
+    }
+    const name = uniqueName(declaration.name, usedNames);
+    const sortedExports = [...exportNames].sort(compare);
+    const exportName = sortedExports.includes("default") ? "default" : sortedExports[0];
+    if (!exportName) {
+      continue;
+    }
+    matched.push({
+      start: declaration.start,
+      component: {
+        name,
+        exportNames: sortedExports,
+        loc: declaration.loc,
+        start: declaration.start,
+        end: declaration.end,
+        props: propsFromDoc(doc)
+      }
+    });
+  }
+  matched.sort((a, b) => a.start - b.start);
+  return matched.map((entry) => entry.component);
+}
+function propsFromDoc(doc) {
+  const props = [];
+  for (const [name, descriptor] of Object.entries(doc.props ?? {})) {
+    const type = typeText(descriptor);
+    const defaultValue = descriptor.defaultValue?.value;
+    props.push({
+      name,
+      required: Boolean(descriptor.required),
+      ...type ? { type } : {},
+      ...defaultValue !== void 0 && defaultValue !== null ? { defaultValue: String(defaultValue) } : {}
+    });
+  }
+  return props.sort((a, b) => compare(a.name, b.name));
+}
+function typeText(descriptor) {
+  return typeDescriptorText(descriptor.tsType) ?? typeDescriptorText(descriptor.flowType) ?? propTypeText(descriptor);
+}
+function typeDescriptorText(descriptor) {
+  if (!descriptor) {
+    return void 0;
+  }
+  const candidate = descriptor;
+  if (typeof candidate.raw === "string" && candidate.raw.length > 0) {
+    return candidate.raw;
+  }
+  if (candidate.name === "literal" && typeof candidate.value === "string") {
+    return candidate.value;
+  }
+  if (typeof candidate.name === "string" && candidate.name.length > 0) {
+    return candidate.name;
+  }
+  return void 0;
+}
+function propTypeText(descriptor) {
+  if (!descriptor.type) {
+    return void 0;
+  }
+  if (typeof descriptor.type.raw === "string" && descriptor.type.raw.length > 0) {
+    return descriptor.type.raw;
+  }
+  if (typeof descriptor.type.name === "string") {
+    return descriptor.type.name;
+  }
+  return void 0;
+}
+function jsxName(name) {
+  if (name.type === "JSXIdentifier") {
+    return isComponentName(name.name) ? { local: name.name } : void 0;
+  }
+  if (name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier" && name.property.type === "JSXIdentifier" && isComponentName(name.object.name)) {
+    return { local: name.object.name, member: name.property.name };
+  }
+  return void 0;
+}
+function isComponentName(name) {
+  return /^[A-Z]/.test(name);
+}
+function declarationName(node) {
+  switch (node.type) {
+    case "Identifier":
+      return node.name;
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return node.id?.name;
+    case "CallExpression": {
+      const argument = node.arguments[0];
+      return argument ? declarationName(argument) : void 0;
+    }
+    case "ParenthesizedExpression":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "TSTypeAssertion":
+      return declarationName(node.expression);
+    default:
+      return void 0;
+  }
+}
+function identifierName(node) {
+  return node.type === "Identifier" ? node.name : void 0;
+}
+function sourceRange(node) {
+  if (!node.loc) {
+    return;
+  }
+  return {
+    start: {
+      line: node.loc.start.line,
+      col: node.loc.start.column + 1
+    },
+    end: {
+      line: node.loc.end.line,
+      col: node.loc.end.column + 1
+    }
+  };
+}
+function uniqueName(name, used) {
+  if (!used.has(name)) {
+    used.add(name);
+    return name;
+  }
+  let counter = 2;
+  while (used.has(`${name}~${counter}`)) {
+    counter += 1;
+  }
+  const unique = `${name}~${counter}`;
+  used.add(unique);
+  return unique;
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function isMissingDefinition(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === ERROR_CODES.MISSING_DEFINITION;
+}
+
+// src/scanner/resolve.ts
+import { existsSync, statSync } from "fs";
+import { dirname, extname, resolve as resolve2 } from "path";
+var RESOLVABLE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mts", ".mjs", ".cts", ".cjs"];
+function createImportResolver(cwd, files) {
+  return (fromFile, rawSource) => {
+    const source = rawSource.split(/[?#]/)[0] ?? rawSource;
+    if (!source) {
+      return void 0;
+    }
+    let base;
+    if (source.startsWith(".")) {
+      base = resolve2(cwd, dirname(fromFile), source);
+    } else if (source.startsWith("/")) {
+      base = resolve2(cwd, source.slice(1));
+    } else {
+      return void 0;
+    }
+    const sourceExtension = extname(base);
+    if (sourceExtension && !RESOLVABLE_EXTENSIONS.includes(sourceExtension)) {
+      return void 0;
+    }
+    const candidates = [];
+    if (sourceExtension) {
+      candidates.push(base);
+      for (const extension of RESOLVABLE_EXTENSIONS) {
+        candidates.push(`${base.slice(0, -sourceExtension.length)}${extension}`);
+      }
+    } else {
+      candidates.push(base);
+      for (const extension of RESOLVABLE_EXTENSIONS) {
+        candidates.push(`${base}${extension}`);
+        candidates.push(resolve2(base, `index${extension}`));
+      }
+    }
+    for (const candidate of candidates) {
+      if (!isFile(candidate)) {
+        continue;
+      }
+      const relative3 = relativePosix(cwd, candidate);
+      if (files.has(relative3)) {
+        return relative3;
+      }
+    }
+    return void 0;
+  };
+}
+function isFile(path) {
+  if (!existsSync(path)) {
+    return false;
+  }
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/scan.ts
+import { createHash } from "crypto";
+import { mkdir, readFile as readFile2, rename, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolve5 } from "path";
+import { glob as glob2 } from "tinyglobby";
+
+// src/schema/manifest.ts
+import { z as z3 } from "zod";
+
+// src/schema/common.ts
+import { z as z2 } from "zod";
+var ConfidenceSchema = z2.enum(["EXTRACTED", "INFERRED"]);
+var PositionSchema = z2.object({
+  line: z2.number().int().positive(),
+  col: z2.number().int().positive()
+});
+var RangeSchema = z2.object({
+  start: PositionSchema,
+  end: PositionSchema
+});
+var PosixPathSchema = z2.string().min(1).refine((value) => !value.includes("\\"), "Use POSIX path separators");
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/schema/version.ts
+var MANIFEST_VERSION = 1;
+var DIAGNOSTICS_VERSION = 1;
+var STYLE_INDEX_VERSION = 1;
+
+// src/schema/manifest.ts
+var PropSchema = z3.object({
+  name: z3.string().min(1),
+  type: z3.string().optional(),
+  required: z3.boolean().default(false),
+  defaultValue: z3.string().optional()
+});
+var ComponentNodeSchema = z3.object({
+  id: z3.string().min(1),
+  kind: z3.literal("component"),
+  name: z3.string().min(1),
+  file: PosixPathSchema,
+  exportName: z3.string().optional(),
+  loc: RangeSchema.optional(),
+  props: z3.array(PropSchema).default([])
+});
+var EdgeRelationSchema = z3.enum(["renders", "imports"]);
+var EdgeSchema = z3.object({
+  from: z3.string().min(1),
+  to: z3.string().min(1),
+  relation: EdgeRelationSchema,
+  confidence: ConfidenceSchema
+});
+var ScanErrorSchema = z3.object({
+  code: z3.string().min(1),
+  file: PosixPathSchema,
+  message: z3.string().min(1)
+});
+var TokenTableSchema = z3.record(z3.string(), z3.string());
+var ManifestSchema = z3.object({
+  version: z3.literal(MANIFEST_VERSION),
+  tokens: TokenTableSchema.default({}),
+  nodes: z3.array(ComponentNodeSchema).default([]),
+  edges: z3.array(EdgeSchema).default([]),
+  errors: z3.array(ScanErrorSchema).default([])
+});
+function sortManifest(manifest) {
+  return {
+    ...manifest,
+    tokens: Object.fromEntries(
+      Object.entries(manifest.tokens).sort(([a], [b]) => compareStrings(a, b))
+    ),
+    nodes: [...manifest.nodes].sort((a, b) => compareStrings(a.id, b.id)),
+    edges: [...manifest.edges].sort((a, b) => {
+      const left = `${a.from}\0${a.to}\0${a.relation}`;
+      const right = `${b.from}\0${b.to}\0${b.relation}`;
+      return compareStrings(left, right);
+    }),
+    errors: [...manifest.errors].sort((a, b) => {
+      const left = `${a.file}\0${a.code}\0${a.message}`;
+      const right = `${b.file}\0${b.code}\0${b.message}`;
+      return compareStrings(left, right);
+    })
+  };
+}
+
+// src/styles/scan.ts
+import { readFile } from "fs/promises";
+import { relative as relative2, resolve as resolve4 } from "path";
+import { glob } from "tinyglobby";
+
+// src/schema/styles.ts
+import { z as z4 } from "zod";
+var StyleDeclarationSchema = z4.object({
+  property: z4.string().min(1),
+  value: z4.string(),
+  important: z4.boolean().default(false),
+  line: z4.number().int().positive(),
+  col: z4.number().int().positive()
+});
+var StyleRuleSchema = z4.object({
+  file: PosixPathSchema,
+  /** The selector exactly as written in the source file, normalized for lookup. */
+  selector: z4.string().min(1),
+  /**
+   * The selector the browser matches after CSS Modules rename classes. Absent
+   * when it is identical to `selector`.
+   */
+  runtimeSelector: z4.string().min(1).optional(),
+  declarations: z4.array(StyleDeclarationSchema).default([]),
+  /** Enclosing conditional at-rules, outermost first, for example `@media (...)` */
+  atRules: z4.array(z4.string()).default([]),
+  /** True when the rule comes from a `*.module.css` file. */
+  module: z4.boolean().default(false),
+  line: z4.number().int().positive(),
+  col: z4.number().int().positive()
+});
+var InlineStyleSchema = z4.object({
+  /** `file:line:col` of the JSX element, matching `data-snoop-src`. */
+  src: z4.string().min(1),
+  file: PosixPathSchema,
+  range: RangeSchema,
+  /** EXTRACTED for an object literal, INFERRED for a spread or expression. */
+  confidence: ConfidenceSchema
+});
+var StyleErrorSchema = z4.object({
+  code: z4.string().min(1),
+  file: PosixPathSchema,
+  message: z4.string().min(1)
+});
+var StyleIndexSchema = z4.object({
+  version: z4.literal(STYLE_INDEX_VERSION),
+  tokens: z4.record(z4.string(), z4.string()).default({}),
+  rules: z4.array(StyleRuleSchema).default([]),
+  inlineStyles: z4.array(InlineStyleSchema).default([]),
+  /** True when the project uses Tailwind classes or a Tailwind config. */
+  tailwind: z4.boolean().default(false),
+  errors: z4.array(StyleErrorSchema).default([])
+});
+function sortStyleIndex(index) {
+  return {
+    ...index,
+    tokens: Object.fromEntries(
+      Object.entries(index.tokens).sort(([a], [b]) => compareStrings(a, b))
+    ),
+    rules: [...index.rules].sort((a, b) => {
+      const left = `${a.file}\0${String(a.line).padStart(8, "0")}\0${String(a.col).padStart(4, "0")}\0${a.selector}\0${a.runtimeSelector ?? ""}`;
+      const right = `${b.file}\0${String(b.line).padStart(8, "0")}\0${String(b.col).padStart(4, "0")}\0${b.selector}\0${b.runtimeSelector ?? ""}`;
+      return compareStrings(left, right);
+    }),
+    inlineStyles: [...index.inlineStyles].sort((a, b) => compareStrings(a.src, b.src)),
+    errors: [...index.errors].sort((a, b) => {
+      const left = `${a.file}\0${a.code}\0${a.message}`;
+      const right = `${b.file}\0${b.code}\0${b.message}`;
+      return compareStrings(left, right);
+    })
+  };
+}
+
+// src/utils/async.ts
+async function mapLimit(items, limit, task) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (true) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) {
+        return;
+      }
+      const item = items[index];
+      if (item === void 0) {
+        return;
+      }
+      results[index] = await task(item, index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+// src/utils/globs.ts
+var ALWAYS_IGNORED = [
+  ".snoop/**",
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**"
+];
+
+// src/styles/css.ts
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
+
+// src/styles/selector.ts
+function normalizeSelector(selector) {
+  return splitSelectorList(selector).map(normalizeComplexSelector).filter((part) => part.length > 0).join(", ");
+}
+function splitSelectorList(selector) {
+  const parts = [];
+  let current = "";
+  let quote;
+  let brackets = 0;
+  let parentheses = 0;
+  for (let index = 0; index < selector.length; index += 1) {
+    const character = selector[index];
+    if (quote) {
+      current += character;
+      if (character === "\\") {
+        const next = selector[index + 1];
+        if (next !== void 0) {
+          current += next;
+          index += 1;
+        }
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      current += character;
+      continue;
+    }
+    if (character === "[") {
+      brackets += 1;
+    } else if (character === "]") {
+      brackets = Math.max(0, brackets - 1);
+    } else if (character === "(") {
+      parentheses += 1;
+    } else if (character === ")") {
+      parentheses = Math.max(0, parentheses - 1);
+    }
+    if (character === "," && brackets === 0 && parentheses === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  parts.push(current);
+  return parts;
+}
+function normalizeComplexSelector(selector) {
+  let output = "";
+  let quote;
+  let brackets = 0;
+  let parentheses = 0;
+  let pendingSpace = false;
+  const flushSpace = () => {
+    if (pendingSpace && output.length > 0 && !/[\s>+~|]$/.test(output)) {
+      output += " ";
+    }
+    pendingSpace = false;
+  };
+  for (let index = 0; index < selector.length; index += 1) {
+    const character = selector[index];
+    if (quote) {
+      output += character;
+      if (character === "\\") {
+        const next = selector[index + 1];
+        if (next !== void 0) {
+          output += next;
+          index += 1;
+        }
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      flushSpace();
+      quote = character;
+      output += character;
+      continue;
+    }
+    if (character === "[") {
+      flushSpace();
+      brackets += 1;
+      output += character;
+      continue;
+    }
+    if (character === "]") {
+      brackets = Math.max(0, brackets - 1);
+      output += character;
+      continue;
+    }
+    if (character === "(") {
+      flushSpace();
+      parentheses += 1;
+      output += character;
+      continue;
+    }
+    if (character === ")") {
+      parentheses = Math.max(0, parentheses - 1);
+      output += character;
+      continue;
+    }
+    if (brackets > 0 || parentheses > 0) {
+      output += character;
+      continue;
+    }
+    if (/\s/.test(character)) {
+      pendingSpace = true;
+      continue;
+    }
+    if (character === ">" || character === "+" || character === "~") {
+      output = output.replace(/\s+$/, "");
+      output += character;
+      pendingSpace = false;
+      continue;
+    }
+    if (character === "|" && selector[index + 1] === "|") {
+      output = output.replace(/\s+$/, "");
+      output += "||";
+      pendingSpace = false;
+      index += 1;
+      continue;
+    }
+    flushSpace();
+    output += character;
+  }
+  return output.trim();
+}
+var LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set(["before", "after", "first-line", "first-letter"]);
+function specificityOf(selector) {
+  let best = { id: 0, class: 0, type: 0 };
+  for (const part of splitSelectorList(selector)) {
+    const value = specificityOfComplexSelector(part);
+    if (compareSpecificity(value, best) > 0) {
+      best = value;
+    }
+  }
+  return best;
+}
+function compareSpecificity(a, b) {
+  return a.id - b.id || a.class - b.class || a.type - b.type;
+}
+function specificityOfComplexSelector(selector) {
+  const result = { id: 0, class: 0, type: 0 };
+  let index = 0;
+  while (index < selector.length) {
+    const character = selector[index];
+    if (/\s/.test(character) || character === ">" || character === "+" || character === "~") {
+      index += 1;
+      continue;
+    }
+    if (character === "," || character === "*") {
+      index += 1;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      index = skipString(selector, index);
+      continue;
+    }
+    if (character === "[") {
+      result.class += 1;
+      index = skipBalanced(selector, index, "[", "]");
+      continue;
+    }
+    if (character === "#") {
+      result.id += 1;
+      index = skipIdentifier(selector, index + 1);
+      continue;
+    }
+    if (character === ".") {
+      result.class += 1;
+      index = skipIdentifier(selector, index + 1);
+      continue;
+    }
+    if (character === ":") {
+      const doubleColon = selector[index + 1] === ":";
+      const nameStart = index + (doubleColon ? 2 : 1);
+      const nameEnd = skipIdentifier(selector, nameStart);
+      const name = selector.slice(nameStart, nameEnd).toLowerCase();
+      if (doubleColon || LEGACY_PSEUDO_ELEMENTS.has(name)) {
+        result.type += 1;
+        index = nameEnd;
+        if (selector[index] === "(") {
+          index = skipBalanced(selector, index, "(", ")");
+        }
+        continue;
+      }
+      if (selector[nameEnd] === "(") {
+        const argumentEnd = skipBalanced(selector, nameEnd, "(", ")");
+        const argument = selector.slice(nameEnd + 1, argumentEnd - 1);
+        if (name === "where") {
+        } else if (name === "is" || name === "not" || name === "has") {
+          addInPlace(result, maxSpecificity(argument));
+        } else if (name === "nth-child" || name === "nth-last-child") {
+          result.class += 1;
+          const ofIndex = findNthOf(argument);
+          if (ofIndex >= 0) {
+            addInPlace(result, maxSpecificity(argument.slice(ofIndex)));
+          }
+        } else {
+          result.class += 1;
+        }
+        index = argumentEnd;
+        continue;
+      }
+      result.class += 1;
+      index = nameEnd;
+      continue;
+    }
+    if (character === "\\") {
+      result.type += 1;
+      index = skipIdentifier(selector, index);
+      continue;
+    }
+    if (character === "&") {
+      index += 1;
+      continue;
+    }
+    if (isIdentifierStart(character)) {
+      const end = skipIdentifier(selector, index);
+      if (selector[end] === "|" && selector[end + 1] !== "|") {
+        index = end + 1;
+        continue;
+      }
+      result.type += 1;
+      index = end;
+      continue;
+    }
+    index += 1;
+  }
+  return result;
+}
+function maxSpecificity(selectorList) {
+  let best = { id: 0, class: 0, type: 0 };
+  for (const part of splitSelectorList(selectorList)) {
+    const value = specificityOfComplexSelector(part);
+    if (compareSpecificity(value, best) > 0) {
+      best = value;
+    }
+  }
+  return best;
+}
+function addInPlace(target, value) {
+  target.id += value.id;
+  target.class += value.class;
+  target.type += value.type;
+}
+function findNthOf(argument) {
+  let quote;
+  let brackets = 0;
+  let parentheses = 0;
+  for (let index = 0; index < argument.length; index += 1) {
+    const character = argument[index];
+    if (quote) {
+      if (character === "\\") {
+        index += 1;
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "[") {
+      brackets += 1;
+    } else if (character === "]") {
+      brackets = Math.max(0, brackets - 1);
+    } else if (character === "(") {
+      parentheses += 1;
+    } else if (character === ")") {
+      parentheses = Math.max(0, parentheses - 1);
+    } else if (brackets === 0 && parentheses === 0 && character.toLowerCase() === "o" && argument[index + 1]?.toLowerCase() === "f" && /\s/.test(argument[index - 1] ?? " ") && /[\s.:#[]/.test(argument[index + 2] ?? " ")) {
+      return index + 2;
+    }
+  }
+  return -1;
+}
+function skipString(value, start) {
+  const quote = value[start];
+  let index = start + 1;
+  while (index < value.length) {
+    if (value[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    if (value[index] === quote) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return value.length;
+}
+function skipBalanced(value, start, open, close) {
+  let depth = 0;
+  let quote;
+  for (let index = start; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (character === "\\") {
+        index += 1;
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === open) {
+      depth += 1;
+    } else if (character === close) {
+      depth -= 1;
+      if (depth === 0) {
+        return index + 1;
+      }
+    }
+  }
+  return value.length;
+}
+function skipIdentifier(value, start) {
+  let index = start;
+  while (index < value.length) {
+    const character = value[index];
+    if (character === "\\") {
+      index += 2;
+      continue;
+    }
+    if (!isIdentifierCharacter(character)) {
+      return index;
+    }
+    index += 1;
+  }
+  return index;
+}
+function isIdentifierStart(character) {
+  return /[a-zA-Z_\u0080-\uffff-]/.test(character);
+}
+function isIdentifierCharacter(character) {
+  return /[a-zA-Z0-9_\u0080-\uffff-]/.test(character);
+}
+
+// src/styles/css.ts
+function parseStyleSheet(file, source, options = {}) {
+  const root = postcss.parse(source, { from: file });
+  const rules = [];
+  const tokens = {};
+  let tailwind = false;
+  let theme = false;
+  root.walkAtRules((atRule) => {
+    if (atRule.name === "tailwind") {
+      tailwind = true;
+    }
+    if (atRule.name === "theme") {
+      theme = true;
+    }
+    if (atRule.name === "import" && /(^|["'\s])tailwindcss(\/|["'\s]|$)/.test(atRule.params)) {
+      tailwind = true;
+    }
+  });
+  root.walkDecls((declaration) => {
+    if (declaration.prop.startsWith("--")) {
+      tokens[declaration.prop] = declaration.value.trim();
+    }
+  });
+  root.walkRules((rule) => {
+    if (isKeyframeRule(rule)) {
+      return;
+    }
+    const selector = normalizeSelector(rule.selector);
+    if (!selector) {
+      return;
+    }
+    const declarations = directDeclarations(rule);
+    if (declarations.length === 0) {
+      return;
+    }
+    const runtimeSelector = options.classMap ? rewriteClasses(selector, options.classMap) : void 0;
+    const normalizedRuntime = runtimeSelector ? normalizeSelector(runtimeSelector) : void 0;
+    rules.push({
+      file,
+      selector,
+      ...normalizedRuntime && normalizedRuntime !== selector ? { runtimeSelector: normalizedRuntime } : {},
+      declarations,
+      atRules: enclosingAtRules(rule),
+      module: file.endsWith(".module.css"),
+      line: rule.source?.start?.line ?? 1,
+      col: rule.source?.start?.column ?? 1
+    });
+  });
+  return { rules, tokens, tailwind, theme };
+}
+function enclosingAtRules(node) {
+  const atRules = [];
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "atrule") {
+      const atRule = parent;
+      if (atRule.name === "media" || atRule.name === "supports" || atRule.name === "container") {
+        atRules.unshift(`@${atRule.name} ${atRule.params}`);
+      } else if (atRule.name === "layer") {
+        atRules.unshift(`@layer ${atRule.params}`);
+      }
+    }
+    parent = parent.parent;
+  }
+  return atRules;
+}
+function directDeclarations(rule) {
+  const declarations = [];
+  for (const node of rule.nodes ?? []) {
+    if (node.type !== "decl") {
+      continue;
+    }
+    const declaration = node;
+    if (declaration.prop === "composes") {
+      continue;
+    }
+    declarations.push({
+      property: declaration.prop,
+      value: declaration.value,
+      important: declaration.important ?? false,
+      line: declaration.source?.start?.line ?? rule.source?.start?.line ?? 1,
+      col: declaration.source?.start?.column ?? rule.source?.start?.column ?? 1
+    });
+  }
+  return declarations;
+}
+function isKeyframeRule(rule) {
+  let parent = rule.parent;
+  while (parent) {
+    if (parent.type === "atrule") {
+      const name = parent.name.toLowerCase();
+      if (name === "keyframes" || name.endsWith("-keyframes")) {
+        return true;
+      }
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function rewriteClasses(selector, classMap) {
+  try {
+    return selectorParser((root) => {
+      root.walkClasses((node) => {
+        const replacement = classMap[node.value];
+        if (replacement) {
+          node.value = replacement;
+        }
+      });
+    }).processSync(selector);
+  } catch {
+    return selector;
+  }
+}
+
+// src/styles/tailwind.ts
+import { existsSync as existsSync2 } from "fs";
+import { createRequire } from "module";
+import { resolve as resolve3 } from "path";
+import { createJiti as createJiti2 } from "jiti";
+var CONFIG_FILES2 = [
+  "tailwind.config.js",
+  "tailwind.config.cjs",
+  "tailwind.config.mjs",
+  "tailwind.config.ts",
+  "tailwind.config.cts",
+  "tailwind.config.mts"
+];
+var CATEGORY_PREFIXES = {
+  colors: "--color",
+  spacing: "--spacing",
+  borderRadius: "--radius",
+  fontSize: "--text",
+  fontFamily: "--font",
+  fontWeight: "--font-weight",
+  boxShadow: "--shadow",
+  screens: "--breakpoint",
+  transitionDuration: "--duration",
+  transitionTimingFunction: "--ease",
+  letterSpacing: "--tracking",
+  lineHeight: "--leading",
+  maxWidth: "--container"
+};
+async function extractTailwindTheme(cwd) {
+  const configFile = CONFIG_FILES2.map((name) => resolve3(cwd, name)).find(
+    (path) => existsSync2(path)
+  );
+  if (!configFile) {
+    return { tokens: {}, found: false, errors: [] };
+  }
+  try {
+    const require2 = createRequire(resolve3(cwd, "package.json"));
+    const resolveConfig = require2("tailwindcss/resolveConfig");
+    const defaultConfig = require2("tailwindcss/defaultConfig");
+    const jiti = createJiti2(import.meta.url, { interopDefault: true });
+    const loaded = await jiti.import(configFile);
+    const userConfig = isRecord2(loaded) && "default" in loaded ? loaded.default : loaded;
+    const resolved = resolveConfig(userConfig);
+    const defaults = resolveConfig(defaultConfig);
+    const tokens = {};
+    for (const [category, prefix] of Object.entries(CATEGORY_PREFIXES)) {
+      const projectValues = flattenCategory(resolved.theme[category]);
+      const defaultValues = flattenCategory(defaults.theme[category]);
+      for (const [path, value] of projectValues) {
+        if (defaultValues.get(path) === value) {
+          continue;
+        }
+        tokens[`${prefix}-${tokenName(path)}`] = value;
+      }
+    }
+    return { tokens, found: true, errors: [] };
+  } catch (error) {
+    return {
+      tokens: {},
+      found: true,
+      errors: [
+        {
+          code: "style/tailwind",
+          file: toRelative(cwd, configFile),
+          message: sanitizeMessage(
+            error instanceof Error ? error.message : "Could not resolve the Tailwind theme",
+            cwd
+          )
+        }
+      ]
+    };
+  }
+}
+function flattenCategory(value) {
+  const result = /* @__PURE__ */ new Map();
+  flatten(value, [], result);
+  return result;
+}
+function flatten(value, path, result) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    const strings = value.filter((entry) => typeof entry === "string");
+    if (strings.length > 0) {
+      result.set(path.join("."), strings.join(", "));
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      flatten(child, [...path, key], result);
+    }
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    result.set(path.join("."), String(value));
+  }
+}
+function tokenName(path) {
+  return path.split(".").filter((part) => part !== "DEFAULT").map(
+    (part) => part.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").toLowerCase()
+  ).filter((part) => part.length > 0).join("-");
+}
+function toRelative(cwd, file) {
+  return file.slice(cwd.length + 1).split("\\").join("/");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/styles/scan.ts
+var READ_CONCURRENCY = 8;
+async function scanStyles(options = {}) {
+  const cwd = resolve4(options.cwd ?? process.cwd());
+  const defaults = ConfigSchema.parse({});
+  const exclude = options.exclude ?? defaults.exclude;
+  const discovered = await glob("**/*.css", {
+    cwd,
+    ignore: [...exclude, ...ALWAYS_IGNORED],
+    absolute: false,
+    onlyFiles: true,
+    dot: false
+  });
+  const files = /* @__PURE__ */ new Set([...discovered.map(toPosixPath), ...tokenFiles(cwd, options.tokenFiles)]);
+  const sortedFiles = [...files].sort(compare2);
+  const moduleFiles = sortedFiles.filter((file) => file.endsWith(".module.css"));
+  const errors = [];
+  let classMaps = {};
+  if (moduleFiles.length > 0 && options.resolveCssModules) {
+    try {
+      classMaps = await options.resolveCssModules(moduleFiles);
+    } catch (error) {
+      errors.push({
+        code: "style/modules",
+        file: moduleFiles[0] ?? "src",
+        message: sanitizeMessage(
+          error instanceof Error ? error.message : "Could not resolve CSS Modules",
+          cwd
+        )
+      });
+    }
+  }
+  const parsed = await mapLimit(sortedFiles, READ_CONCURRENCY, async (file) => {
+    const absolutePath = resolve4(cwd, file);
+    try {
+      const source = await readFile(absolutePath, "utf8");
+      return {
+        file,
+        result: parseStyleSheet(file, source, {
+          ...classMaps[file] ? { classMap: classMaps[file] } : {}
+        })
+      };
+    } catch (error) {
+      errors.push({
+        code: "style/parse",
+        file,
+        message: sanitizeMessage(
+          error instanceof Error ? error.message : "Could not parse CSS",
+          cwd
+        )
+      });
+      return void 0;
+    }
+  });
+  const tailwind = await extractTailwindTheme(cwd);
+  errors.push(...tailwind.errors);
+  const tokens = { ...tailwind.tokens };
+  const rules = [];
+  let usesTailwind = tailwind.found;
+  for (const entry of parsed) {
+    if (!entry) {
+      continue;
+    }
+    rules.push(...entry.result.rules);
+    Object.assign(tokens, entry.result.tokens);
+    usesTailwind = usesTailwind || entry.result.tailwind || entry.result.theme;
+  }
+  return StyleIndexSchema.parse(
+    sortStyleIndex({
+      version: STYLE_INDEX_VERSION,
+      tokens,
+      rules,
+      inlineStyles: [...options.inlineStyles ?? []],
+      tailwind: usesTailwind,
+      errors
+    })
+  );
+}
+function tokenFiles(cwd, entries) {
+  if (!entries) {
+    return [];
+  }
+  return entries.map((entry) => toPosixPath(relative2(cwd, resolve4(cwd, entry)))).filter((entry) => entry.length > 0);
+}
+function compare2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/rules/index.ts
+var RULE_NAMES = [
+  "token/hardcoded-match",
+  "token/near-match",
+  "token/undefined-var"
+];
+function createRulesEngine(context, enabled = {}) {
+  const allDiagnostics = [];
+  if (enabled["token/hardcoded-match"] !== false) {
+    allDiagnostics.push(...runHardcodedTokenMatch(context).diagnostics);
+  }
+  if (enabled["token/near-match"] !== false) {
+    allDiagnostics.push(...runNearTokenMatch(context).diagnostics);
+  }
+  if (enabled["token/undefined-var"] !== false) {
+    allDiagnostics.push(...runUndefinedCssVar(context).diagnostics);
+  }
+  return { diagnostics: allDiagnostics };
+}
+function runHardcodedTokenMatch(context) {
+  const { manifest, styleIndex } = context;
+  const diagnostics = [];
+  const tokenValues = /* @__PURE__ */ new Map();
+  for (const [token, value] of Object.entries(manifest.tokens)) {
+    tokenValues.set(normalizeTokenValue(value), token);
+  }
+  for (const rule of styleIndex.rules) {
+    for (const declaration of rule.declarations) {
+      if (declaration.property.startsWith("--")) continue;
+      if (isLengthOrColor(declaration.value)) {
+        const normalized = normalizeTokenValue(declaration.value);
+        const token = tokenValues.get(normalized);
+        if (token) {
+          if (!declaration.value.includes("var(")) {
+            diagnostics.push({
+              code: "token/hardcoded-match",
+              severity: "warning",
+              confidence: "EXTRACTED",
+              file: rule.file,
+              range: {
+                start: { line: declaration.line, col: declaration.col },
+                end: { line: declaration.line, col: declaration.col + declaration.value.length }
+              },
+              message: `${declaration.property}: ${declaration.value} matches token ${token} (${normalized}).`,
+              fix: { kind: "replace", text: `var(${token})` },
+              fingerprint: `token/hardcoded-match:${rule.file}:${declaration.property}:${normalized}`
+            });
+          }
+        }
+      }
+    }
+  }
+  return { diagnostics };
+}
+function runNearTokenMatch(context) {
+  const { manifest, styleIndex, config } = context;
+  const diagnostics = [];
+  const tolerance = config.tolerance.px;
+  const tokenLengths = [];
+  for (const [token, value] of Object.entries(manifest.tokens)) {
+    const parsed = parseLength(value);
+    if (parsed) {
+      tokenLengths.push({ token, value, ...parsed });
+    }
+  }
+  for (const rule of styleIndex.rules) {
+    for (const declaration of rule.declarations) {
+      if (declaration.property.startsWith("--")) continue;
+      const parsed = parseLength(declaration.value);
+      if (!parsed) continue;
+      if (declaration.value.includes("var(")) continue;
+      for (const token of tokenLengths) {
+        if (parsed.unit !== token.unit) continue;
+        const pixelsPerUnit = PIXELS_PER_UNIT[parsed.unit];
+        if (pixelsPerUnit === void 0) continue;
+        const diff = Math.abs(parsed.numeric - token.numeric) * pixelsPerUnit;
+        if (diff > 0 && diff <= tolerance) {
+          diagnostics.push({
+            code: "token/near-match",
+            severity: "info",
+            confidence: "INFERRED",
+            file: rule.file,
+            range: {
+              start: { line: declaration.line, col: declaration.col },
+              end: { line: declaration.line, col: declaration.col + declaration.value.length }
+            },
+            message: `${declaration.property}: ${declaration.value} is close to ${token.token} (${token.value}).`,
+            fix: { kind: "replace", text: `var(${token.token})` },
+            fingerprint: `token/near-match:${rule.file}:${declaration.property}:${parsed.numeric}${parsed.unit}:${token.token}`
+          });
+        }
+      }
+    }
+  }
+  return { diagnostics };
+}
+function runUndefinedCssVar(context) {
+  const { manifest, styleIndex } = context;
+  const diagnostics = [];
+  const definedTokens = new Set(Object.keys(manifest.tokens));
+  for (const rule of styleIndex.rules) {
+    for (const declaration of rule.declarations) {
+      if (declaration.property.startsWith("--")) {
+        definedTokens.add(declaration.property);
+      }
+    }
+  }
+  for (const rule of styleIndex.rules) {
+    for (const declaration of rule.declarations) {
+      const varMatches = declaration.value.match(/var\((--[^)]+)\)/g);
+      if (!varMatches) continue;
+      for (const match of varMatches) {
+        const varName = match.slice(4, -1).trim().split(",")[0]?.trim() ?? "";
+        if (!definedTokens.has(varName)) {
+          const suggestion = findClosestToken(varName, definedTokens);
+          diagnostics.push({
+            code: "token/undefined-var",
+            severity: "error",
+            confidence: "INFERRED",
+            file: rule.file,
+            range: {
+              start: { line: declaration.line, col: declaration.col },
+              end: { line: declaration.line, col: declaration.col + declaration.value.length }
+            },
+            message: `Undefined CSS variable ${varName}.${suggestion ? ` Did you mean ${suggestion}?` : ""}`,
+            fix: suggestion ? { kind: "replace", text: declaration.value.replace(varName, suggestion) } : void 0,
+            fingerprint: `token/undefined-var:${rule.file}:${varName}`
+          });
+        }
+      }
+    }
+  }
+  return { diagnostics };
+}
+var PIXELS_PER_UNIT = {
+  px: 1,
+  rem: 16
+};
+function normalizeTokenValue(value) {
+  return value.trim().toLowerCase();
+}
+function isLengthOrColor(value) {
+  const trimmed = value.trim();
+  if (/^[\d.]+\s*(px|rem|em|ch|ex|vw|vh|vmin|vmax|cm|mm|in|pt|pc)$/i.test(trimmed)) {
+    return true;
+  }
+  if (/^(#[0-9a-f]{3,8}|rgb\(|rgba\(|hsl\(|hsla\()/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function parseLength(value) {
+  const match = /^([\d.]+)\s*(px|rem|em|ch|ex|vw|vh|vmin|vmax|cm|mm|in|pt|pc)$/i.exec(value.trim());
+  if (!match || !match[1] || !match[2]) return null;
+  return { numeric: parseFloat(match[1]), unit: match[2].toLowerCase() };
+}
+function findClosestToken(target, candidates) {
+  let best = null;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(target, candidate);
+    if (distance < bestDistance && distance <= 3) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function levenshteinDistance(a, b) {
+  const matrix = Array.from(
+    { length: b.length + 1 },
+    () => Array.from({ length: a.length + 1 }, () => 0)
+  );
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i][0] = i;
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+// src/schema/diagnostics.ts
+import { z as z5 } from "zod";
+var SeveritySchema = z5.enum(["info", "warning", "error"]);
+var DiagnosticFixSchema = z5.object({
+  kind: z5.literal("replace"),
+  text: z5.string()
+});
+var DiagnosticSchema = z5.object({
+  code: z5.string().min(1),
+  severity: SeveritySchema,
+  confidence: ConfidenceSchema,
+  file: PosixPathSchema,
+  range: RangeSchema,
+  message: z5.string().min(1),
+  fix: DiagnosticFixSchema.optional(),
+  /**
+   * Stable identifier for baselines. It must not include line numbers, so an
+   * edit elsewhere in the file does not resurface a known issue.
+   */
+  fingerprint: z5.string().min(1)
+});
+var DiagnosticsFileSchema = z5.object({
+  version: z5.literal(DIAGNOSTICS_VERSION),
+  diagnostics: z5.array(DiagnosticSchema).default([])
+});
+function sortDiagnostics(file) {
+  return {
+    ...file,
+    diagnostics: [...file.diagnostics].sort((a, b) => {
+      const left = `${a.file}\0${String(a.range.start.line).padStart(8, "0")}\0${a.code}\0${a.fingerprint}`;
+      const right = `${b.file}\0${String(b.range.start.line).padStart(8, "0")}\0${b.code}\0${b.fingerprint}`;
+      return compareStrings(left, right);
+    })
+  };
+}
+
+// src/scanner/types.ts
+import { z as z6 } from "zod";
+var ComponentAnalysisSchema = z6.object({
+  name: z6.string().min(1),
+  /** Every name this component is exported under, including `default`. */
+  exportNames: z6.array(z6.string().min(1)).min(1),
+  loc: RangeSchema,
+  /** Character offsets, used to attribute JSX to the smallest containing component. */
+  start: z6.number().int().nonnegative(),
+  end: z6.number().int().nonnegative(),
+  props: z6.array(PropSchema)
+});
+var ImportBindingSchema = z6.object({
+  source: z6.string().min(1),
+  /** `default`, `*`, or the imported export name. */
+  imported: z6.string().min(1),
+  local: z6.string().min(1)
+});
+var JsxUsageSchema = z6.object({
+  local: z6.string().min(1),
+  member: z6.string().min(1).optional(),
+  start: z6.number().int().nonnegative(),
+  loc: RangeSchema
+});
+var InlineStyleAnalysisSchema = z6.object({
+  /** `file:line:col` of the tagged JSX element. */
+  src: z6.string().min(1),
+  file: PosixPathSchema,
+  range: RangeSchema,
+  /** EXTRACTED for an object literal, INFERRED for a spread or expression. */
+  confidence: ConfidenceSchema
+});
+var FileAnalysisSchema = z6.object({
+  file: PosixPathSchema,
+  hash: z6.string().regex(/^[a-f0-9]{64}$/),
+  components: z6.array(ComponentAnalysisSchema),
+  imports: z6.array(ImportBindingSchema),
+  usages: z6.array(JsxUsageSchema),
+  inlineStyles: z6.array(InlineStyleAnalysisSchema).default([])
+});
+var SCANNER_CACHE_VERSION = 2;
+var ScannerCacheSchema = z6.object({
+  version: z6.literal(SCANNER_CACHE_VERSION),
+  files: z6.record(PosixPathSchema, FileAnalysisSchema)
+});
+
+// src/scanner/scan.ts
+var CACHE_PATH = ".snoop/cache/scanner.v2.json";
+var READ_CONCURRENCY2 = 8;
+async function scanProject(options = {}) {
+  const cwd = resolve5(options.cwd ?? process.cwd());
+  const defaults = ConfigSchema.parse({});
+  const include = options.include ?? defaults.include;
+  const exclude = options.exclude ?? defaults.exclude;
+  const useCache = options.cache !== false;
+  const cachePath = resolve5(cwd, CACHE_PATH);
+  const discovered = await glob2(include, {
+    cwd,
+    ignore: [...exclude, ...ALWAYS_IGNORED],
+    absolute: false,
+    onlyFiles: true,
+    dot: false
+  });
+  const files = [...new Set(discovered.map(toPosixPath))].sort(compare3);
+  const fileSet = new Set(files);
+  const cache = useCache ? await readCache(cachePath) : void 0;
+  const results = await mapLimit(files, READ_CONCURRENCY2, async (file) => {
+    const absolutePath = resolve5(cwd, file);
+    let source;
+    try {
+      source = await readFile2(absolutePath, "utf8");
+    } catch (error) {
+      return {
+        error: {
+          code: "scan/read",
+          file,
+          message: sanitizeMessage(
+            error instanceof Error ? error.message : "Could not read file",
+            cwd
+          )
+        },
+        cached: false,
+        parsed: false
+      };
+    }
+    const hash = hashSource(source);
+    const cached = cache?.files[file];
+    if (cached && cached.hash === hash) {
+      return { analysis: cached, cached: true, parsed: false };
+    }
+    const analyzed = analyzeFile({
+      absolutePath,
+      cwd,
+      file,
+      hash,
+      source
+    });
+    return {
+      ...analyzed.analysis ? { analysis: analyzed.analysis } : {},
+      ...analyzed.error ? { error: analyzed.error } : {},
+      cached: false,
+      parsed: true
+    };
+  });
+  const analyses = results.flatMap((result) => result.analysis ? [result.analysis] : []);
+  const errors = results.flatMap((result) => result.error ? [result.error] : []);
+  if (useCache) {
+    await writeCache(cachePath, analyses);
+  }
+  const componentIds = /* @__PURE__ */ new Map();
+  const componentsByFile = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const analysis of [...analyses].sort((a, b) => compare3(a.file, b.file))) {
+    componentsByFile.set(analysis.file, analysis.components);
+    for (const component of analysis.components) {
+      const id = uniqueId(`cmp:${analysis.file}#${component.name}`, usedIds);
+      const exportName = component.exportNames.includes("default") ? "default" : component.exportNames[0];
+      componentIds.set(component, id);
+      nodes.push({
+        id,
+        kind: "component",
+        name: component.name,
+        file: analysis.file,
+        ...exportName ? { exportName } : {},
+        loc: component.loc,
+        props: component.props
+      });
+    }
+  }
+  const edges = /* @__PURE__ */ new Map();
+  const addEdge = (from, to, relation, confidence) => {
+    if (!from || !to) {
+      return;
+    }
+    const key = `${from}\0${to}\0${relation}`;
+    if (!edges.has(key)) {
+      edges.set(key, { from, to, relation, confidence });
+    }
+  };
+  const resolveImport = createImportResolver(cwd, fileSet);
+  for (const analysis of analyses) {
+    const components = analysis.components;
+    const importTargets = /* @__PURE__ */ new Map();
+    const namespaceTargets = /* @__PURE__ */ new Map();
+    for (const binding of analysis.imports) {
+      const targetFile = resolveImport(analysis.file, binding.source);
+      if (!targetFile) {
+        continue;
+      }
+      const targetComponents = componentsByFile.get(targetFile) ?? [];
+      if (binding.imported === "*") {
+        namespaceTargets.set(binding.local, targetComponents);
+        continue;
+      }
+      const target = selectComponent(targetComponents, binding.imported);
+      if (target) {
+        importTargets.set(binding.local, target);
+      }
+    }
+    for (const usage of analysis.usages) {
+      const source = containingComponent(components, usage.start);
+      if (!source) {
+        continue;
+      }
+      let target;
+      if (usage.member) {
+        const namespace = namespaceTargets.get(usage.local);
+        if (namespace) {
+          target = selectComponent(namespace, usage.member);
+        }
+      } else {
+        target = components.find((component) => component.name === usage.local) ?? importTargets.get(usage.local);
+      }
+      addEdge(
+        componentIds.get(source),
+        target ? componentIds.get(target) : void 0,
+        "renders",
+        "EXTRACTED"
+      );
+    }
+    if (components.length === 1) {
+      const source = components[0];
+      if (!source) {
+        continue;
+      }
+      for (const target of new Set(importTargets.values())) {
+        if (target === source) {
+          continue;
+        }
+        const fromId = componentIds.get(source);
+        const toId = componentIds.get(target);
+        if (!fromId || !toId || hasEdgeBetween(edges, fromId, toId)) {
+          continue;
+        }
+        addEdge(fromId, toId, "imports", "EXTRACTED");
+      }
+    }
+  }
+  const styles = await scanStyles({
+    cwd,
+    ...options.tokens ? { tokenFiles: options.tokens } : {},
+    exclude,
+    inlineStyles: analyses.flatMap((analysis) => analysis.inlineStyles),
+    ...options.resolveCssModules ? { resolveCssModules: options.resolveCssModules } : {}
+  });
+  const manifest = ManifestSchema.parse(
+    sortManifest({
+      version: MANIFEST_VERSION,
+      tokens: styles.tokens,
+      nodes,
+      edges: [...edges.values()],
+      errors
+    })
+  );
+  const config = ConfigSchema.parse({
+    include,
+    exclude,
+    ...options.tokens ? { tokens: options.tokens } : {}
+  });
+  const rulesResult = createRulesEngine({ manifest, styleIndex: styles, config });
+  const diagnostics = DiagnosticsFileSchema.parse(
+    sortDiagnostics({
+      version: 1,
+      diagnostics: rulesResult.diagnostics
+    })
+  );
+  return {
+    manifest,
+    styles,
+    diagnostics,
+    stats: {
+      files: files.length,
+      parsedFiles: results.filter((result) => result.parsed).length,
+      cachedFiles: results.filter((result) => result.cached).length,
+      components: nodes.length,
+      edges: edges.size,
+      errors: errors.length
+    }
+  };
+}
+async function writeManifest(outPath, manifest) {
+  await mkdir(dirname2(outPath), { recursive: true });
+  await writeFile(outPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function selectComponent(components, imported) {
+  return components.find((component) => component.exportNames.includes(imported)) ?? components.find((component) => component.name === imported);
+}
+function containingComponent(components, start) {
+  let best;
+  for (const component of components) {
+    if (start < component.start || start >= component.end) {
+      continue;
+    }
+    if (!best || component.end - component.start < best.end - best.start) {
+      best = component;
+    }
+  }
+  return best;
+}
+function hasEdgeBetween(edges, from, to) {
+  const prefix = `${from}\0${to}\0`;
+  for (const key of edges.keys()) {
+    if (key.startsWith(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function uniqueId(candidate, used) {
+  if (!used.has(candidate)) {
+    used.add(candidate);
+    return candidate;
+  }
+  let counter = 2;
+  while (used.has(`${candidate}~${counter}`)) {
+    counter += 1;
+  }
+  const unique = `${candidate}~${counter}`;
+  used.add(unique);
+  return unique;
+}
+async function readCache(path) {
+  try {
+    const raw = await readFile2(path, "utf8");
+    const parsed = ScannerCacheSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeCache(path, analyses) {
+  try {
+    await mkdir(dirname2(path), { recursive: true });
+    const files = {};
+    for (const analysis of [...analyses].sort((a, b) => compare3(a.file, b.file))) {
+      files[analysis.file] = analysis;
+    }
+    const payload = {
+      version: SCANNER_CACHE_VERSION,
+      files
+    };
+    const temporaryPath = `${path}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+    await rename(temporaryPath, path);
+  } catch {
+  }
+}
+function hashSource(source) {
+  return createHash("sha256").update(source).digest("hex");
+}
+function compare3(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/scanner/containment.ts
+function parseSourceLocation(src) {
+  const match = /^(.*):(\d+):(\d+)$/.exec(src);
+  if (!match) {
+    return void 0;
+  }
+  const [, file, line, col] = match;
+  if (!file) {
+    return void 0;
+  }
+  return { file, line: Number(line), col: Number(col) };
+}
+
+// src/styles/provenance.ts
+function createStyleIndexer(index) {
+  const staticRules = /* @__PURE__ */ new Map();
+  for (const rule of index.rules) {
+    addRule(staticRules, rule.selector, rule);
+    if (rule.runtimeSelector) {
+      addRule(staticRules, rule.runtimeSelector, rule);
+    }
+  }
+  const inlineBySrc = /* @__PURE__ */ new Map();
+  for (const inline of index.inlineStyles) {
+    inlineBySrc.set(inline.src, inline);
+  }
+  return {
+    resolve(detail) {
+      const provenance = {};
+      const matchedRules = detail.matchedRules ?? [];
+      const inlineStyle = detail.inlineStyle ?? {};
+      const classes = detail.classes ?? [];
+      for (const [property, value] of Object.entries(detail.style)) {
+        const candidates = [];
+        if (inlineStyle[property] !== void 0) {
+          candidates.push({
+            declaration: {
+              property,
+              value: inlineStyle[property] ?? value,
+              important: false
+            },
+            specificity: { id: 1e6, class: 0, type: 0 },
+            important: false,
+            order: Number.MAX_SAFE_INTEGER,
+            inline: true
+          });
+        }
+        for (const rule of matchedRules) {
+          for (const declaration of rule.declarations) {
+            if (declaration.property !== property) {
+              continue;
+            }
+            candidates.push({
+              rule,
+              declaration,
+              specificity: specificityOf(rule.selector),
+              important: declaration.important,
+              order: rule.order,
+              inline: false
+            });
+          }
+        }
+        if (candidates.length === 0) {
+          continue;
+        }
+        const winner = candidates.reduce(
+          (best, candidate) => isBetter(candidate, best) ? candidate : best
+        );
+        const source = winner.inline ? inlineSource(detail.src, inlineBySrc) : stylesheetSource(winner, staticRules, index, detail, classes);
+        provenance[property] = source;
+      }
+      return provenance;
+    }
+  };
+}
+function addRule(target, selector, rule) {
+  const key = normalizeSelector(selector);
+  const list = target.get(key) ?? [];
+  target.set(key, list);
+  for (const declaration of rule.declarations) {
+    list.push({ rule, declaration });
+  }
+}
+function isBetter(candidate, current) {
+  if (candidate.important !== current.important) {
+    return candidate.important;
+  }
+  const specificity = compareSpecificity(candidate.specificity, current.specificity);
+  if (specificity !== 0) {
+    return specificity > 0;
+  }
+  return candidate.order >= current.order;
+}
+function inlineSource(src, inlineBySrc) {
+  const inline = inlineBySrc.get(src);
+  if (inline) {
+    return {
+      kind: "inline",
+      file: inline.file,
+      line: inline.range.start.line,
+      col: inline.range.start.col,
+      selector: "style",
+      confidence: inline.confidence
+    };
+  }
+  const location = parseSourceLocation(src);
+  return {
+    kind: "inline",
+    ...location ? { file: location.file, line: location.line, col: location.col } : {},
+    selector: "style",
+    confidence: "INFERRED"
+  };
+}
+function stylesheetSource(winner, staticRules, index, detail, classes) {
+  const rule = winner.rule;
+  const selector = rule?.selector ?? "style";
+  const atRules = rule?.atRules ?? [];
+  const matches = staticRules.get(normalizeSelector(selector)) ?? [];
+  const properties = [winner.declaration.property, ...shorthandsFor(winner.declaration.property)];
+  const forProperty = matches.filter((match) => properties.includes(match.declaration.property)).sort(
+    (a, b) => properties.indexOf(a.declaration.property) - properties.indexOf(b.declaration.property)
+  );
+  if (forProperty.length > 0) {
+    const exact = forProperty.find(
+      (match) => normalizeValue(match.declaration.value) === normalizeValue(winner.declaration.value)
+    );
+    const chosen = exact ?? forProperty[0];
+    const locations = new Set(
+      forProperty.map((match) => `${match.rule.file}:${match.declaration.line}`)
+    );
+    const confidence = locations.size === 1 ? "EXTRACTED" : "INFERRED";
+    return {
+      kind: chosen.rule.module ? "css-module" : "stylesheet",
+      file: chosen.rule.file,
+      line: chosen.declaration.line,
+      col: chosen.declaration.col,
+      selector,
+      ...atRules.length > 0 ? { atRules } : {},
+      ...locations.size > 1 ? { candidates: locations.size } : {},
+      confidence
+    };
+  }
+  if (index.tailwind && isTailwindUtility(selector, classes)) {
+    const location = parseSourceLocation(detail.src);
+    return {
+      kind: "tailwind",
+      ...location ? { file: location.file, line: location.line, col: location.col } : {},
+      selector,
+      ...atRules.length > 0 ? { atRules } : {},
+      confidence: "INFERRED"
+    };
+  }
+  return {
+    kind: "unknown",
+    selector,
+    ...atRules.length > 0 ? { atRules } : {},
+    confidence: "INFERRED"
+  };
+}
+function shorthandsFor(property) {
+  const shorthands = [];
+  const box = /^(margin|padding)-(?:top|right|bottom|left)$/.exec(property);
+  if (box?.[1]) {
+    shorthands.push(box[1]);
+  }
+  const borderWidth = /^border-(top|right|bottom|left)-width$/.exec(property);
+  if (borderWidth?.[1]) {
+    shorthands.push(`border-${borderWidth[1]}`, "border-width", "border");
+  }
+  if (/^border-(?:top|bottom)-(?:left|right)-radius$/.test(property)) {
+    shorthands.push("border-radius");
+  }
+  if (property === "background-color") {
+    shorthands.push("background");
+  }
+  if (property === "flex-direction" || property === "flex-wrap") {
+    shorthands.push("flex-flow");
+  }
+  if (/^(?:row|column)-gap$/.test(property)) {
+    shorthands.push("gap");
+  }
+  if (/^font-(?:size|weight|family)$|^line-height$/.test(property)) {
+    shorthands.push("font");
+  }
+  if (property.startsWith("grid-template-")) {
+    shorthands.push("grid-template", "grid");
+  }
+  if (property.startsWith("overflow-")) {
+    shorthands.push("overflow");
+  }
+  return shorthands;
+}
+function normalizeValue(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function isTailwindUtility(selector, classes) {
+  const match = /^\.((?:\\.|[^.#:[\]\s>+~])+)/.exec(selector);
+  if (!match?.[1]) {
+    return false;
+  }
+  const className = match[1].replace(/\\(.)/g, "$1");
+  if (!classes.includes(className)) {
+    return false;
+  }
+  const remainder = selector.slice(match[0].length);
+  return /^(?::[a-zA-Z-]+(?:\([^)]*\))?)*$/.test(remainder);
+}
+
+// src/runtime/protocol.ts
+var AGENT_ROLE = "agent";
+var DASHBOARD_ROLE = "dashboard";
+function isAgentMessage(value) {
+  if (!isRecord3(value) || typeof value.kind !== "string") {
+    return false;
+  }
+  switch (value.kind) {
+    case "ready":
+    case "presence":
+    case "elements":
+    case "detail":
+    case "click":
+    case "hover":
+      return true;
+    default:
+      return false;
+  }
+}
+function isDashboardMessage(value) {
+  if (!isRecord3(value) || typeof value.kind !== "string") {
+    return false;
+  }
+  switch (value.kind) {
+    case "measure":
+    case "inspect":
+    case "isolate":
+    case "select":
+    case "sync":
+      return true;
+    default:
+      return false;
+  }
+}
+function isRelayEnvelope(value) {
+  return isRecord3(value) && value.type === "relay" && isRecord3(value.payload) && typeof value.payload.kind === "string";
+}
+function parseRole(value) {
+  return value === AGENT_ROLE ? AGENT_ROLE : DASHBOARD_ROLE;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/index.ts
+var VERSION = package_default.version;
+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,
+  isRecord3 as isRecord,
+  isRelayEnvelope,
+  loadConfig,
+  normalizeSelector,
+  parseRole,
+  parseStyleSheet,
+  rewriteClasses,
+  scanProject,
+  scanStyles,
+  sortDiagnostics,
+  sortManifest,
+  sortStyleIndex,
+  specificityOf,
+  writeManifest
+};
+//# sourceMappingURL=index.js.map