@dryui/mcp 0.1.0

package/dist/workspace-audit.js

@@ -0,0 +1,2099 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/utils.ts
+function buildLineOffsets(text) {
+  const offsets = [0];
+  for (let i = 0;i < text.length; i++) {
+    if (text[i] === `
+`)
+      offsets.push(i + 1);
+  }
+  return offsets;
+}
+function lineAtOffset(lineOffsets, offset) {
+  let lo = 0;
+  let hi = lineOffsets.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    const midVal = lineOffsets[mid];
+    if (midVal !== undefined && midVal <= offset)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return lo + 1;
+}
+
+// src/reviewer.ts
+function extractImports(code) {
+  const imports = new Set;
+  const scriptMatch = code.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  if (!scriptMatch)
+    return imports;
+  const scriptContent = scriptMatch[1] ?? "";
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@dryui\/(ui|primitives)['"]/g;
+  let match;
+  while ((match = importRegex.exec(scriptContent)) !== null) {
+    const raw = match[1] ?? "";
+    const names = raw.split(",");
+    for (const name of names) {
+      const trimmed = name.trim();
+      if (trimmed)
+        imports.add(trimmed);
+    }
+  }
+  return imports;
+}
+function extractTags(code) {
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const tagRegex = /<([A-Z][a-zA-Z0-9]*(?:\.[A-Z][a-zA-Z0-9]*)*)\s*([^>]*?)(\/)?>/g;
+  const tags = [];
+  let match;
+  while ((match = tagRegex.exec(template)) !== null) {
+    const name = match[1] ?? "";
+    const attrsStr = match[2] ?? "";
+    const selfClosing = match[3] === "/";
+    const line = lineAtOffset(lineOffsets, match.index);
+    const props = extractPropsFromAttrs(attrsStr);
+    const hasSpread = /\{\.\.\./.test(attrsStr);
+    tags.push({ name, line, props, hasSpread, selfClosing });
+  }
+  return tags;
+}
+function extractStyles(code) {
+  const styleMatch = code.match(/<style[^>]*>([\s\S]*?)<\/style>/);
+  return styleMatch ? styleMatch[1] ?? null : null;
+}
+function countNewlines(str) {
+  let count = 0;
+  for (let i = 0;i < str.length; i++) {
+    if (str[i] === `
+`)
+      count++;
+  }
+  return count;
+}
+function stripBraceExpressions(str) {
+  let result = "";
+  let depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    if (str[i] === "{") {
+      if (depth === 0)
+        result += "{}";
+      depth++;
+    } else if (str[i] === "}") {
+      depth--;
+    } else if (depth === 0) {
+      result += str[i];
+    }
+  }
+  return result;
+}
+function extractPropsFromAttrs(attrsStr) {
+  const props = [];
+  if (!attrsStr.trim())
+    return props;
+  const stripped = stripBraceExpressions(attrsStr.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''"));
+  const bindRegex = /\bbind:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let m;
+  while ((m = bindRegex.exec(stripped)) !== null) {
+    const bound = m[1];
+    if (bound)
+      props.push("bind:" + bound);
+  }
+  const namedRegex = /\b([a-zA-Z_][a-zA-Z0-9_-]*)\s*=/g;
+  while ((m = namedRegex.exec(stripped)) !== null) {
+    const propName = m[1];
+    if (propName && !props.includes(propName)) {
+      props.push(propName);
+    }
+  }
+  const boolRegex = /(?<!\.)(?<![:{])\b([a-zA-Z_][a-zA-Z0-9_-]*)\b(?!\s*=)/g;
+  while ((m = boolRegex.exec(stripped)) !== null) {
+    const propName = m[1];
+    if (!propName)
+      continue;
+    if (props.includes(propName) || props.includes("bind:" + propName) || propName === "bind") {
+      continue;
+    }
+    props.push(propName);
+  }
+  return props;
+}
+var NATIVE_HTML_ATTRS = new Set([
+  "id",
+  "class",
+  "style",
+  "title",
+  "lang",
+  "dir",
+  "tabindex",
+  "hidden",
+  "role",
+  "slot",
+  "is",
+  "part",
+  "translate",
+  "draggable",
+  "contenteditable",
+  "spellcheck",
+  "autocapitalize",
+  "inputmode",
+  "enterkeyhint",
+  "children",
+  "name",
+  "value",
+  "type",
+  "placeholder",
+  "required",
+  "readonly",
+  "disabled",
+  "checked",
+  "selected",
+  "multiple",
+  "autofocus",
+  "autocomplete",
+  "pattern",
+  "min",
+  "max",
+  "step",
+  "minlength",
+  "maxlength",
+  "form",
+  "formaction",
+  "formmethod",
+  "formtarget",
+  "formnovalidate",
+  "accept",
+  "capture",
+  "list",
+  "size",
+  "href",
+  "target",
+  "rel",
+  "download",
+  "src",
+  "alt",
+  "width",
+  "height",
+  "loading",
+  "decoding",
+  "crossorigin",
+  "referrerpolicy",
+  "for",
+  "htmlFor"
+]);
+function isPropAllowed(propName) {
+  if (NATIVE_HTML_ATTRS.has(propName))
+    return true;
+  if (propName.startsWith("aria-"))
+    return true;
+  if (propName.startsWith("data-"))
+    return true;
+  if (propName.startsWith("on"))
+    return true;
+  if (propName.startsWith("bind:"))
+    return true;
+  return false;
+}
+function checkBareCompound(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.name.includes("."))
+      continue;
+    const def = spec.components[tag.name];
+    if (!def?.compound)
+      continue;
+    const partNames = Object.keys(def.parts ?? {});
+    const hasRootPart = partNames.includes("Root");
+    const firstPart = partNames.find((part) => part !== "Root");
+    if (hasRootPart) {
+      issues.push({
+        severity: "error",
+        code: "bare-compound",
+        line: tag.line,
+        message: `<${tag.name}> is a compound component — use <${tag.name}.Root>`,
+        fix: `<${tag.name}.Root>`
+      });
+      continue;
+    }
+    issues.push({
+      severity: "error",
+      code: "bare-compound",
+      line: tag.line,
+      message: `<${tag.name}> is a namespaced component — use a part like <${tag.name}.${firstPart ?? "Text"}>`,
+      fix: `<${tag.name}.${firstPart ?? "Text"}>`
+    });
+  }
+  return issues;
+}
+function checkUnknownComponent(tags, imports, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    const root = tag.name.split(".")[0] ?? tag.name;
+    if (imports.has(root) && !spec.components[root]) {
+      issues.push({
+        severity: "error",
+        code: "unknown-component",
+        line: tag.line,
+        message: `<${tag.name}> is not a known DryUI component`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkInvalidPartName(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (!tag.name.includes("."))
+      continue;
+    const parts = tag.name.split(".");
+    const root = parts[0] ?? "";
+    const part = parts[1] ?? "";
+    if (!root || !part)
+      continue;
+    const def = spec.components[root];
+    if (!def?.compound || !def.parts)
+      continue;
+    if (!def.parts[part]) {
+      const validParts = Object.keys(def.parts);
+      issues.push({
+        severity: "error",
+        code: "invalid-part",
+        line: tag.line,
+        message: `<${root}.${part}> — "${part}" is not a valid part of ${root}. Valid parts: ${validParts.join(", ")}`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkInvalidProp(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    const segments = tag.name.split(".");
+    const root = segments[0] ?? "";
+    const part = segments[1];
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def)
+      continue;
+    let specProps;
+    if (part) {
+      specProps = def.parts?.[part]?.props;
+    } else if (!def.compound) {
+      specProps = def.props;
+    } else {
+      continue;
+    }
+    if (!specProps)
+      continue;
+    for (const prop of tag.props) {
+      const checkName = prop.startsWith("bind:") ? prop.slice(5) : prop;
+      if (isPropAllowed(prop))
+        continue;
+      if (!specProps[checkName]) {
+        issues.push({
+          severity: "error",
+          code: "invalid-prop",
+          line: tag.line,
+          message: `<${tag.name}> does not accept prop "${checkName}"`,
+          fix: null
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkMissingRequiredProp(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.hasSpread)
+      continue;
+    const segments = tag.name.split(".");
+    const root = segments[0] ?? "";
+    const part = segments[1];
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def)
+      continue;
+    let specProps;
+    if (part) {
+      specProps = def.parts?.[part]?.props;
+    } else if (!def.compound) {
+      specProps = def.props;
+    } else {
+      continue;
+    }
+    if (!specProps)
+      continue;
+    const tagPropNames = new Set(tag.props.map((p) => p.startsWith("bind:") ? p.slice(5) : p));
+    for (const [propName, propDef] of Object.entries(specProps)) {
+      if (propDef.required && !tagPropNames.has(propName)) {
+        if (propName === "children" && !tag.selfClosing)
+          continue;
+        issues.push({
+          severity: "error",
+          code: "missing-required-prop",
+          line: tag.line,
+          message: `<${tag.name}> is missing required prop "${propName}"`,
+          fix: `${propName}={...}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkOrphanedPart(tags, spec) {
+  const issues = [];
+  const allNames = new Set(tags.map((t) => t.name));
+  for (const tag of tags) {
+    if (!tag.name.includes("."))
+      continue;
+    const root = tag.name.split(".")[0] ?? "";
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def?.compound || !def.parts?.Root)
+      continue;
+    if (!allNames.has(`${root}.Root`)) {
+      issues.push({
+        severity: "warning",
+        code: "orphaned-part",
+        line: tag.line,
+        message: `<${tag.name}> used without <${root}.Root> in the template`,
+        fix: `Wrap in <${root}.Root>`
+      });
+    }
+  }
+  return issues;
+}
+function checkMissingLabel(tags, code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  for (const tag of tags) {
+    if (tag.name !== "Input" && tag.name !== "Select.Root" && tag.name !== "Combobox.Input")
+      continue;
+    const hasAriaLabel = tag.props.some((p) => p === "aria-label");
+    if (hasAriaLabel)
+      continue;
+    const tagOffset = findTagOffset(template, tag.name, tag.line, lineOffsets);
+    const wrappedByField = tagOffset !== -1 && template.lastIndexOf("<Field.Root", tagOffset) !== -1 && template.indexOf("</Field.Root>", tagOffset) !== -1;
+    if (!wrappedByField) {
+      issues.push({
+        severity: "warning",
+        code: "missing-label",
+        line: tag.line,
+        message: `<${tag.name}> may be missing an accessible label — add aria-label or wrap in <Field.Root> with <Label>`,
+        fix: 'aria-label="..."'
+      });
+    }
+  }
+  return issues;
+}
+function findTagOffset(template, tagName, targetLine, lineOffsets) {
+  const regex = new RegExp(`<${tagName.replace(".", "\\.")}[\\s/>]`, "g");
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    if (line === targetLine)
+      return match.index;
+  }
+  return -1;
+}
+function checkMissingThumbnail(imports, spec) {
+  if (!spec.thumbnails)
+    return [];
+  const issues = [];
+  const thumbnailSet = new Set(spec.thumbnails);
+  for (const name of imports) {
+    if (!spec.components[name])
+      continue;
+    if (!thumbnailSet.has(name)) {
+      issues.push({
+        severity: "warning",
+        code: "missing-thumbnail",
+        line: 1,
+        message: `Component '${name}' has no SVG thumbnail — run 'bun run thumbnail:create ${name}'`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkImageWithoutAlt(tags) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.name !== "Avatar")
+      continue;
+    const hasAlt = tag.props.includes("alt");
+    const hasFallback = tag.props.includes("fallback");
+    if (!hasAlt && !hasFallback) {
+      issues.push({
+        severity: "warning",
+        code: "missing-alt",
+        line: tag.line,
+        message: '<Avatar> is missing "alt" and "fallback" props for accessibility',
+        fix: 'alt="..."'
+      });
+    }
+  }
+  return issues;
+}
+function checkCustomGridLayout(styles, code) {
+  const issues = [];
+  if (/display:\s*grid/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*grid/);
+    issues.push({
+      severity: "warning",
+      code: "use-grid-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Grid> component instead of custom CSS grid. Grid provides responsive columns, gap tokens, and breakpoint handling.",
+      fix: '<Grid --dry-grid-columns="repeat(2, 1fr)" --dry-grid-gap="var(--dry-space-4)">'
+    });
+  }
+  return issues;
+}
+function checkCustomFlexLayout(styles, code) {
+  const issues = [];
+  if (/display:\s*flex/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*flex/);
+    issues.push({
+      severity: "warning",
+      code: "use-flex-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Flex> or <Stack> component instead of custom CSS flexbox. These provide gap, alignment, and responsive behavior with theme tokens.",
+      fix: "<Flex> or <Stack>"
+    });
+  }
+  return issues;
+}
+function checkCustomFieldMarkup(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const fieldClassRegex = /class=["']field["']/g;
+  let match;
+  while ((match = fieldClassRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-field-component",
+      line,
+      message: "Use <Field.Root> + <Label> instead of custom field markup. Field provides accessible labeling, error states, and consistent spacing.",
+      fix: "<Field.Root> + <Label>"
+    });
+  }
+  const manualFieldRegex = /<span[^>]*>[\s\S]*?<\/span>\s*<(?:input|select|textarea)[\s/>]/g;
+  while ((match = manualFieldRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-field-component",
+      line,
+      message: "Use <Field.Root> + <Label> instead of custom field markup. Field provides accessible labeling, error states, and consistent spacing.",
+      fix: "<Field.Root> + <Label>"
+    });
+  }
+  return issues;
+}
+function checkRawStyledButton(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const rawBtnRegex = /<button\s[^>]*class=/g;
+  let match;
+  while ((match = rawBtnRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-button-component",
+      line,
+      message: "Use DryUI's <Button> component instead of raw <button> with custom classes. Button provides variants, sizes, loading states, and theme-consistent styling.",
+      fix: "<Button>"
+    });
+  }
+  return issues;
+}
+function checkCustomMaxWidthCentering(styles, code) {
+  const issues = [];
+  if (/max-width/.test(styles) && /margin[^;]*auto/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /max-width/);
+    issues.push({
+      severity: "warning",
+      code: "use-container-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Container> component instead of custom max-width + margin centering.",
+      fix: "<Container>"
+    });
+  }
+  return issues;
+}
+function getStyleBlockStartLine(code) {
+  const idx = code.search(/<style[^>]*>/);
+  if (idx === -1)
+    return 1;
+  const lineOffsets = buildLineOffsets(code);
+  const tagEndIdx = code.indexOf(">", idx) + 1;
+  return lineAtOffset(lineOffsets, tagEndIdx);
+}
+function styleLineToFileLine(lineInStyleBlock, styleStartLine) {
+  return styleStartLine + lineInStyleBlock - 1;
+}
+function findLineInBlock(block, regex) {
+  const lines = block.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== undefined && regex.test(line))
+      return i + 1;
+  }
+  return 1;
+}
+function checkManualFlex(styles, code) {
+  const issues = [];
+  if (/display:\s*flex/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*flex/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-layout",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Manual `display: flex` detected — consider using <Flex> or <Stack> instead",
+      fix: "<Flex> or <Stack>"
+    });
+  }
+  return issues;
+}
+function checkManualGrid(styles, code) {
+  const issues = [];
+  if (/display:\s*grid/.test(styles) && /grid-template-columns/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*grid/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-layout",
+      line: styleLineToFileLine(localLine, startLine),
+      message: 'Manual CSS grid detected — consider using <Grid --dry-grid-columns="repeat(2, 1fr)"> instead',
+      fix: '<Grid --dry-grid-columns="repeat(2, 1fr)" --dry-grid-gap="var(--dry-space-4)">'
+    });
+  }
+  return issues;
+}
+function checkHardcodedColors(styles, code) {
+  const issues = [];
+  const colorRegex = /(?:^|;)\s*(?:color|background(?:-color)?)\s*:\s*(?!.*var\s*\()/m;
+  if (colorRegex.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /(?:color|background(?:-color)?)\s*:\s*(?!.*var\s*\()/);
+    issues.push({
+      severity: "suggestion",
+      code: "hardcoded-color",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Hardcoded color value — consider using `--dry-*` CSS custom properties for theming",
+      fix: "var(--dry-*)"
+    });
+  }
+  return issues;
+}
+function checkManualCentering(styles, code) {
+  const issues = [];
+  if (/max-width/.test(styles) && /margin:\s*[^;]*auto/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /max-width/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-container",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Manual centering with max-width + margin auto — consider using <Container> instead",
+      fix: "<Container>"
+    });
+  }
+  return issues;
+}
+function checkCustomThemeOverrides(styles, code) {
+  if (!styles || !/--dry-/.test(styles))
+    return [];
+  return [
+    {
+      severity: "suggestion",
+      code: "theme-in-style",
+      line: getStyleBlockStartLine(code),
+      message: "Custom --dry-* variable overrides detected in <style> — run the `diagnose` tool on your theme CSS for a full health check",
+      fix: null
+    }
+  ];
+}
+function checkRawHr(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const hrRegex = /<hr[\s/>]/g;
+  const lineOffsets = buildLineOffsets(code);
+  let match;
+  while ((match = hrRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-separator",
+      line,
+      message: "Raw <hr> element — consider using <Separator /> for consistent styling",
+      fix: "<Separator />"
+    });
+  }
+  return issues;
+}
+function reviewComponent(code, spec, filename) {
+  const imports = extractImports(code);
+  const tags = extractTags(code);
+  const styles = extractStyles(code);
+  const issues = [];
+  issues.push(...checkBareCompound(tags, spec));
+  issues.push(...checkUnknownComponent(tags, imports, spec));
+  issues.push(...checkInvalidPartName(tags, spec));
+  issues.push(...checkInvalidProp(tags, spec));
+  issues.push(...checkMissingRequiredProp(tags, spec));
+  issues.push(...checkOrphanedPart(tags, spec));
+  issues.push(...checkMissingLabel(tags, code));
+  issues.push(...checkImageWithoutAlt(tags));
+  issues.push(...checkMissingThumbnail(imports, spec));
+  issues.push(...checkCustomFieldMarkup(code));
+  issues.push(...checkRawStyledButton(code));
+  if (styles) {
+    issues.push(...checkCustomGridLayout(styles, code));
+    issues.push(...checkCustomFlexLayout(styles, code));
+    issues.push(...checkCustomMaxWidthCentering(styles, code));
+  }
+  if (styles) {
+    issues.push(...checkManualFlex(styles, code));
+    issues.push(...checkManualGrid(styles, code));
+    issues.push(...checkHardcodedColors(styles, code));
+    issues.push(...checkManualCentering(styles, code));
+    issues.push(...checkCustomThemeOverrides(styles, code));
+  }
+  issues.push(...checkRawHr(code));
+  issues.sort((a, b) => a.line - b.line);
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  const suggestions = issues.filter((i) => i.severity === "suggestion").length;
+  const summary = issues.length === 0 ? "No issues found" : `${errors} error${errors !== 1 ? "s" : ""}, ${warnings} warning${warnings !== 1 ? "s" : ""}, ${suggestions} suggestion${suggestions !== 1 ? "s" : ""}`;
+  return { issues, summary, ...filename ? { filename } : {} };
+}
+
+// src/theme-checker.ts
+function capture(match, index) {
+  const value = match[index];
+  if (value === undefined)
+    throw new Error(`Missing capture group ${index}`);
+  return value;
+}
+var REQUIRED_TOKENS = [
+  "--dry-color-text-strong",
+  "--dry-color-text-weak",
+  "--dry-color-icon",
+  "--dry-color-stroke-strong",
+  "--dry-color-stroke-weak",
+  "--dry-color-fill",
+  "--dry-color-fill-hover",
+  "--dry-color-fill-active",
+  "--dry-color-brand",
+  "--dry-color-text-brand",
+  "--dry-color-fill-brand",
+  "--dry-color-fill-brand-hover",
+  "--dry-color-fill-brand-active",
+  "--dry-color-fill-brand-weak",
+  "--dry-color-stroke-brand",
+  "--dry-color-on-brand",
+  "--dry-color-focus-ring",
+  "--dry-color-bg-base",
+  "--dry-color-bg-raised",
+  "--dry-color-bg-overlay",
+  "--dry-color-text-error",
+  "--dry-color-fill-error",
+  "--dry-color-fill-error-hover",
+  "--dry-color-fill-error-weak",
+  "--dry-color-stroke-error",
+  "--dry-color-on-error",
+  "--dry-color-text-warning",
+  "--dry-color-fill-warning",
+  "--dry-color-fill-warning-hover",
+  "--dry-color-fill-warning-weak",
+  "--dry-color-stroke-warning",
+  "--dry-color-on-warning",
+  "--dry-color-text-success",
+  "--dry-color-fill-success",
+  "--dry-color-fill-success-hover",
+  "--dry-color-fill-success-weak",
+  "--dry-color-stroke-success",
+  "--dry-color-on-success",
+  "--dry-color-text-info",
+  "--dry-color-fill-info",
+  "--dry-color-fill-info-hover",
+  "--dry-color-fill-info-weak",
+  "--dry-color-stroke-info",
+  "--dry-color-on-info",
+  "--dry-shadow-raised",
+  "--dry-shadow-overlay",
+  "--dry-color-overlay-backdrop",
+  "--dry-color-overlay-backdrop-strong"
+];
+var FULL_THEME_THRESHOLD = 4;
+var NAMED_COLORS = new Set([
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkgrey",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkslategrey",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dimgrey",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "grey",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightgrey",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightslategrey",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "slategrey",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen",
+  "transparent",
+  "currentcolor",
+  "inherit"
+]);
+var SURFACE_TOKENS = new Set([
+  "--dry-color-bg-base",
+  "--dry-color-bg-raised",
+  "--dry-color-bg-overlay"
+]);
+function stripComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function extractDryVariables(css) {
+  const cleaned = stripComments(css);
+  const vars = new Map;
+  const regex = /(--dry-[a-zA-Z0-9-]+)\s*:\s*([^;]*);/g;
+  let match;
+  const lineOffsets = buildLineOffsets(cleaned);
+  while ((match = regex.exec(cleaned)) !== null) {
+    const name = capture(match, 1);
+    const value = (match[2] ?? "").trim();
+    const line = lineAtOffset(lineOffsets, match.index);
+    vars.set(name, { value, line });
+  }
+  return vars;
+}
+function extractAllVariables(css) {
+  const cleaned = stripComments(css);
+  const vars = new Map;
+  const regex = /(--[a-zA-Z0-9-]+)\s*:\s*([^;]*);/g;
+  let match;
+  while ((match = regex.exec(cleaned)) !== null) {
+    const name = capture(match, 1);
+    const value = (match[2] ?? "").trim();
+    vars.set(name, value);
+  }
+  return vars;
+}
+function parseVarFunc(value) {
+  const prefix = /^var\(\s*/.exec(value);
+  if (!prefix)
+    return null;
+  let pos = prefix[0].length;
+  const nameMatch = /^(--[a-zA-Z0-9-]+)/.exec(value.slice(pos));
+  if (!nameMatch)
+    return null;
+  const refName = capture(nameMatch, 1);
+  pos += refName.length;
+  while (pos < value.length && /\s/.test(value[pos]))
+    pos++;
+  if (value[pos] === ")")
+    return { refName, fallback: null };
+  if (value[pos] !== ",")
+    return { refName, fallback: null };
+  pos++;
+  while (pos < value.length && /\s/.test(value[pos]))
+    pos++;
+  let depth = 1;
+  const fallbackStart = pos;
+  while (pos < value.length && depth > 0) {
+    if (value[pos] === "(")
+      depth++;
+    else if (value[pos] === ")")
+      depth--;
+    if (depth > 0)
+      pos++;
+  }
+  const fallback = value.slice(fallbackStart, pos).trim();
+  return { refName, fallback: fallback || null };
+}
+function resolveVarReferences(dryVars, allVars) {
+  const resolved = new Map;
+  for (const [name, entry] of dryVars) {
+    const parsed = parseVarFunc(entry.value);
+    if (!parsed) {
+      resolved.set(name, { original: entry.value, resolved: entry.value, line: entry.line });
+      continue;
+    }
+    const { refName, fallback } = parsed;
+    const refValue = allVars.get(refName);
+    if (refValue !== undefined) {
+      resolved.set(name, { original: entry.value, resolved: refValue, line: entry.line });
+    } else if (fallback !== null) {
+      resolved.set(name, { original: entry.value, resolved: fallback, line: entry.line });
+    } else {
+      resolved.set(name, { original: entry.value, resolved: entry.value, line: entry.line });
+    }
+  }
+  return resolved;
+}
+function classifyValue(value) {
+  const v = value.trim();
+  if (!v)
+    return "other";
+  if (/^#([0-9a-fA-F]{3,8})$/.test(v))
+    return "color";
+  if (/^rgba?\s*\(/.test(v))
+    return "color";
+  if (/^hsla?\s*\(/.test(v))
+    return "color";
+  if (/^color-mix\s*\(/.test(v))
+    return "color";
+  if (NAMED_COLORS.has(v.toLowerCase()))
+    return "color";
+  if (/^(?:oklch|lch|lab|oklab|color)\s*\(/.test(v))
+    return "color";
+  if (/^-?[\d.]+(?:px|rem|em|%|vw|vh)$/.test(v))
+    return "length";
+  if (/^-?[\d.]+(?:ms|s)$/.test(v))
+    return "time";
+  if (/^-?[\d.]+(?:px|rem|em)\s+-?[\d.]+(?:px|rem|em)/.test(v))
+    return "shadow";
+  if (/^["']/.test(v))
+    return "font";
+  if (/,\s*["']?[a-zA-Z]/.test(v) && !/^(rgb|hsl)/.test(v))
+    return "font";
+  return "other";
+}
+function parseColor(value) {
+  const v = value.trim();
+  const hexMatch = v.match(/^#([0-9a-fA-F]{3,8})$/);
+  if (hexMatch) {
+    const hex = capture(hexMatch, 1);
+    if (hex.length === 3) {
+      return {
+        r: parseInt(hex.charAt(0) + hex.charAt(0), 16),
+        g: parseInt(hex.charAt(1) + hex.charAt(1), 16),
+        b: parseInt(hex.charAt(2) + hex.charAt(2), 16)
+      };
+    }
+    if (hex.length === 6 || hex.length === 8) {
+      return {
+        r: parseInt(hex.slice(0, 2), 16),
+        g: parseInt(hex.slice(2, 4), 16),
+        b: parseInt(hex.slice(4, 6), 16)
+      };
+    }
+    return null;
+  }
+  const rgbMatch = v.match(/^rgba?\(\s*(\d+)\s*[,/]\s*(\d+)\s*[,/]\s*(\d+)/);
+  if (rgbMatch) {
+    return {
+      r: parseInt(capture(rgbMatch, 1), 10),
+      g: parseInt(capture(rgbMatch, 2), 10),
+      b: parseInt(capture(rgbMatch, 3), 10)
+    };
+  }
+  const hslMatch = v.match(/^hsla?\(\s*(\d+)\s*[,/]\s*([\d.]+)%?\s*[,/]\s*([\d.]+)%?/);
+  if (hslMatch) {
+    const h = parseInt(capture(hslMatch, 1), 10);
+    const s = parseFloat(capture(hslMatch, 2)) / 100;
+    const l = parseFloat(capture(hslMatch, 3)) / 100;
+    return hslToRgb(h, s, l);
+  }
+  const modernRgbMatch = v.match(/^rgba?\(\s*(\d+)\s+(\d+)\s+(\d+)/);
+  if (modernRgbMatch) {
+    return {
+      r: parseInt(capture(modernRgbMatch, 1), 10),
+      g: parseInt(capture(modernRgbMatch, 2), 10),
+      b: parseInt(capture(modernRgbMatch, 3), 10)
+    };
+  }
+  const modernHslMatch = v.match(/^hsla?\(\s*(\d+)\s+([\d.]+)%?\s+([\d.]+)%?/);
+  if (modernHslMatch) {
+    const h = parseInt(capture(modernHslMatch, 1), 10);
+    const s = parseFloat(capture(modernHslMatch, 2)) / 100;
+    const l = parseFloat(capture(modernHslMatch, 3)) / 100;
+    return hslToRgb(h, s, l);
+  }
+  return null;
+}
+function hslToRgb(h, s, l) {
+  const hue = (h % 360 + 360) % 360;
+  if (s === 0) {
+    const val = Math.round(l * 255);
+    return { r: val, g: val, b: val };
+  }
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  function hueToChannel(t) {
+    let tc = t;
+    if (tc < 0)
+      tc += 1;
+    if (tc > 1)
+      tc -= 1;
+    if (tc < 1 / 6)
+      return p + (q - p) * 6 * tc;
+    if (tc < 1 / 2)
+      return q;
+    if (tc < 2 / 3)
+      return p + (q - p) * (2 / 3 - tc) * 6;
+    return p;
+  }
+  return {
+    r: Math.round(hueToChannel(hue / 360 + 1 / 3) * 255),
+    g: Math.round(hueToChannel(hue / 360) * 255),
+    b: Math.round(hueToChannel(hue / 360 - 1 / 3) * 255)
+  };
+}
+function brightness(r, g, b) {
+  return (r * 299 + g * 587 + b * 114) / 1000;
+}
+function extractAlpha(value) {
+  const v = value.trim();
+  const modernRgbMatch = v.match(/^rgba?\(\s*[\d.]+\s+[\d.]+\s+[\d.]+\s*\/\s*([\d.]+%?)\s*\)/);
+  if (modernRgbMatch) {
+    const val = capture(modernRgbMatch, 1);
+    return val.endsWith("%") ? parseFloat(val) / 100 : parseFloat(val);
+  }
+  const modernHslMatch = v.match(/^hsla?\(\s*[\d.]+\s+[\d.]+%?\s+[\d.]+%?\s*\/\s*([\d.]+%?)\s*\)/);
+  if (modernHslMatch) {
+    const val = capture(modernHslMatch, 1);
+    return val.endsWith("%") ? parseFloat(val) / 100 : parseFloat(val);
+  }
+  const rgbaMatch = v.match(/^rgba\(\s*\d+\s*[,/]\s*\d+\s*[,/]\s*\d+\s*[,/]\s*([\d.]+)\s*\)/);
+  if (rgbaMatch) {
+    return parseFloat(capture(rgbaMatch, 1));
+  }
+  const hslaMatch = v.match(/^hsla\(\s*\d+\s*[,/]\s*[\d.]+%?\s*[,/]\s*[\d.]+%?\s*[,/]\s*([\d.]+)\s*\)/);
+  if (hslaMatch) {
+    return parseFloat(capture(hslaMatch, 1));
+  }
+  const hex8Match = v.match(/^#[0-9a-fA-F]{8}$/);
+  if (hex8Match) {
+    const alphaHex = v.slice(7, 9);
+    return parseInt(alphaHex, 16) / 255;
+  }
+  return 1;
+}
+function checkMissingTokens(vars) {
+  const semanticCount = REQUIRED_TOKENS.filter((t) => vars.has(t)).length;
+  if (semanticCount < FULL_THEME_THRESHOLD)
+    return [];
+  const issues = [];
+  for (const token of REQUIRED_TOKENS) {
+    if (!vars.has(token)) {
+      issues.push({
+        severity: "error",
+        code: "missing-token",
+        variable: token,
+        message: `Required semantic token ${token} is not defined`,
+        fix: `Add ${token} with a color that fits your theme`
+      });
+    }
+  }
+  return issues;
+}
+function checkValueTypes(vars) {
+  const issues = [];
+  for (const [name, entry] of vars) {
+    const val = entry.resolved;
+    if (/^var\(\s*--/.test(val))
+      continue;
+    const classified = classifyValue(val);
+    if (/^--dry-color-/.test(name) && classified !== "color" && classified !== "other") {
+      issues.push({
+        severity: "error",
+        code: "wrong-type",
+        variable: name,
+        value: entry.original,
+        message: `${name} expects a color value but got "${val}" (classified as ${classified})`,
+        fix: `Replace with a color value (e.g., #2563eb, rgb(37,99,235), hsl(217,91%,60%))`
+      });
+    }
+    if (/^--dry-space-/.test(name) && classified !== "length" && classified !== "other") {
+      issues.push({
+        severity: "error",
+        code: "wrong-type",
+        variable: name,
+        value: entry.original,
+        message: `${name} expects a length value but got "${val}" (classified as ${classified})`,
+        fix: `Replace with a length value (e.g., 0.5rem, 4px, 1em)`
+      });
+    }
+    if (/^--dry-radius-/.test(name) && classified !== "length" && classified !== "other") {
+      issues.push({
+        severity: "error",
+        code: "wrong-type",
+        variable: name,
+        value: entry.original,
+        message: `${name} expects a length value but got "${val}" (classified as ${classified})`,
+        fix: `Replace with a length value (e.g., 4px, 0.375rem)`
+      });
+    }
+    if (/^--dry-duration-/.test(name) && classified !== "time" && classified !== "other") {
+      issues.push({
+        severity: "error",
+        code: "wrong-type",
+        variable: name,
+        value: entry.original,
+        message: `${name} expects a time value but got "${val}" (classified as ${classified})`,
+        fix: `Replace with a time value (e.g., 100ms, 0.2s)`
+      });
+    }
+  }
+  return issues;
+}
+function checkContrastHeuristics(vars) {
+  const issues = [];
+  for (const token of SURFACE_TOKENS) {
+    const entry = vars.get(token);
+    if (!entry)
+      continue;
+    const alpha = extractAlpha(entry.resolved);
+    if (alpha < 0.3) {
+      issues.push({
+        severity: "warning",
+        code: "transparent-surface",
+        variable: token,
+        value: entry.original,
+        message: `Surface color has very low opacity (${alpha}) — cards and elevated elements will be nearly invisible`,
+        fix: `Use a solid color (e.g., #1e293b for dark themes, #f8fafc for light themes)`
+      });
+    }
+  }
+  const textStrongEntry = vars.get("--dry-color-text-strong");
+  const textWeakEntry = vars.get("--dry-color-text-weak");
+  const textBrandEntry = vars.get("--dry-color-text-brand");
+  const bgBaseEntry = vars.get("--dry-color-bg-base");
+  if (bgBaseEntry) {
+    const bgRgb = parseColor(bgBaseEntry.resolved);
+    if (bgRgb) {
+      const bgBrightness = brightness(bgRgb.r, bgRgb.g, bgRgb.b);
+      const textPairs = [
+        ["--dry-color-text-strong", textStrongEntry],
+        ["--dry-color-text-weak", textWeakEntry],
+        ["--dry-color-text-brand", textBrandEntry]
+      ];
+      for (const [tokenName, textEntry] of textPairs) {
+        if (!textEntry)
+          continue;
+        const textRgb = parseColor(textEntry.resolved);
+        if (!textRgb)
+          continue;
+        const textBrightness = brightness(textRgb.r, textRgb.g, textRgb.b);
+        if (Math.abs(textBrightness - bgBrightness) < 125) {
+          issues.push({
+            severity: "warning",
+            code: "low-contrast-text",
+            variable: tokenName,
+            value: textEntry.original,
+            message: `Low contrast between ${tokenName} and --dry-color-bg-base (brightness difference: ${Math.round(Math.abs(textBrightness - bgBrightness))})`,
+            fix: `Increase brightness difference between text and background to at least 125`
+          });
+        }
+      }
+    }
+  }
+  const bgRaisedEntry = vars.get("--dry-color-bg-raised");
+  const bgOverlayEntry = vars.get("--dry-color-bg-overlay");
+  if (bgBaseEntry && bgRaisedEntry) {
+    const baseRgb = parseColor(bgBaseEntry.resolved);
+    const raisedRgb = parseColor(bgRaisedEntry.resolved);
+    if (baseRgb && raisedRgb) {
+      const baseBr = brightness(baseRgb.r, baseRgb.g, baseRgb.b);
+      const raisedBr = brightness(raisedRgb.r, raisedRgb.g, raisedRgb.b);
+      if (Math.abs(baseBr - raisedBr) < 3) {
+        issues.push({
+          severity: "warning",
+          code: "no-elevation",
+          variable: "--dry-color-bg-raised",
+          value: bgRaisedEntry.original,
+          message: `--dry-color-bg-base and --dry-color-bg-raised have near-identical brightness (difference: ${Math.round(Math.abs(baseBr - raisedBr))}) — raised surfaces won't have visual separation`,
+          fix: `Make --dry-color-bg-raised 1-2 steps lighter/darker than --dry-color-bg-base`
+        });
+      }
+    }
+  }
+  if (bgRaisedEntry && bgOverlayEntry) {
+    const raisedRgb = parseColor(bgRaisedEntry.resolved);
+    const overlayRgb = parseColor(bgOverlayEntry.resolved);
+    if (raisedRgb && overlayRgb) {
+      const raisedBr = brightness(raisedRgb.r, raisedRgb.g, raisedRgb.b);
+      const overlayBr = brightness(overlayRgb.r, overlayRgb.g, overlayRgb.b);
+      if (Math.abs(raisedBr - overlayBr) < 3) {
+        issues.push({
+          severity: "warning",
+          code: "no-elevation",
+          variable: "--dry-color-bg-overlay",
+          value: bgOverlayEntry.original,
+          message: `--dry-color-bg-raised and --dry-color-bg-overlay have near-identical brightness (difference: ${Math.round(Math.abs(raisedBr - overlayBr))}) — overlay surfaces won't have visual separation`,
+          fix: `Make --dry-color-bg-overlay 1-2 steps lighter/darker than --dry-color-bg-raised`
+        });
+      }
+    }
+  }
+  const pairings = [
+    ["--dry-color-fill-brand", "--dry-color-on-brand"],
+    ["--dry-color-fill-error", "--dry-color-on-error"],
+    ["--dry-color-fill-warning", "--dry-color-on-warning"],
+    ["--dry-color-fill-success", "--dry-color-on-success"],
+    ["--dry-color-fill-info", "--dry-color-on-info"]
+  ];
+  for (const [a, b] of pairings) {
+    if (vars.has(a) && !vars.has(b)) {
+      issues.push({
+        severity: "warning",
+        code: "missing-pairing",
+        variable: b,
+        message: `${a} is defined but its pair ${b} is missing`,
+        fix: `Add ${b} to complete the color pairing`
+      });
+    }
+    if (vars.has(b) && !vars.has(a)) {
+      issues.push({
+        severity: "warning",
+        code: "missing-pairing",
+        variable: a,
+        message: `${b} is defined but its pair ${a} is missing`,
+        fix: `Add ${a} to complete the color pairing`
+      });
+    }
+  }
+  return issues;
+}
+function checkComponentTokens(vars, spec) {
+  const issues = [];
+  const validComponentVars = new Set;
+  for (const comp of Object.values(spec.components)) {
+    for (const varName of Object.keys(comp.cssVars)) {
+      validComponentVars.add(varName);
+    }
+  }
+  for (const [name, entry] of vars) {
+    if (/^--dry-(?:color|space|radius|duration|shadow|text|font)-/.test(name))
+      continue;
+    if (!validComponentVars.has(name)) {
+      issues.push({
+        severity: "warning",
+        code: "unknown-component-token",
+        variable: name,
+        value: entry.original,
+        message: `${name} is not a recognized component token in the spec`,
+        fix: `Check spelling against the component's cssVars in the spec`
+      });
+      continue;
+    }
+    if (/-bg$/.test(name)) {
+      const lower = entry.resolved.toLowerCase();
+      if (lower === "transparent") {
+        issues.push({
+          severity: "warning",
+          code: "transparent-component-bg",
+          variable: name,
+          value: entry.original,
+          message: `${name} is set to transparent — the component background will be invisible`,
+          fix: `Use a solid color or reference a background token (e.g., var(--dry-color-bg-raised))`
+        });
+      } else {
+        const alpha = extractAlpha(entry.resolved);
+        if (alpha < 0.3) {
+          issues.push({
+            severity: "warning",
+            code: "transparent-component-bg",
+            variable: name,
+            value: entry.original,
+            message: `${name} has very low opacity (${alpha}) — the component background will be nearly invisible`,
+            fix: `Use a solid color or reference a background token (e.g., var(--dry-color-bg-raised))`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function detectDarkScheme(css, allVars) {
+  const issues = [];
+  const signals = [];
+  if (/color-scheme\s*:\s*dark/i.test(css)) {
+    signals.push("color-scheme: dark");
+  }
+  const bgVarNames = ["--bg", "--background", "--bg-color", "--background-color", "--bg-base"];
+  for (const name of bgVarNames) {
+    const value = allVars.get(name);
+    if (value) {
+      const rgb = parseColor(value);
+      if (rgb && brightness(rgb.r, rgb.g, rgb.b) < 50) {
+        signals.push(`${name}: ${value} (dark)`);
+      }
+    }
+  }
+  const bgPropMatch = css.match(/(?:html|body|\*|:root)\s*\{[^}]*background(?:-color)?\s*:\s*([^;]+)/i);
+  if (bgPropMatch) {
+    const val = (bgPropMatch[1] ?? "").trim();
+    const varRef = val.match(/var\(\s*(--[a-zA-Z0-9-]+)/);
+    const resolvedVal = varRef?.[1] ? allVars.get(varRef[1]) : undefined;
+    const colorStr = resolvedVal ?? val;
+    const rgb = parseColor(colorStr);
+    if (rgb && brightness(rgb.r, rgb.g, rgb.b) < 50) {
+      signals.push(`background: ${val} (dark)`);
+    }
+  }
+  if (signals.length > 0) {
+    issues.push({
+      severity: "warning",
+      code: "dark-scheme-no-overrides",
+      variable: "--dry-color-*",
+      message: `Project uses a dark color scheme (${signals.join(", ")}) but has no --dry-color-* overrides. DryUI's default theme is light — components will have poor contrast on dark backgrounds. Either use theme: "dark" in the generate tool, or add --dry-color-* overrides to map DryUI tokens to your dark palette.`,
+      fix: 'Use theme: "dark" in dryui.page(), or override --dry-color-bg-base, --dry-color-bg-raised, --dry-color-text-strong, --dry-color-text-weak, and other semantic tokens with dark-appropriate values'
+    });
+  }
+  return issues;
+}
+function diagnoseTheme(css, spec) {
+  const dryVars = extractDryVariables(css);
+  const allVars = extractAllVariables(css);
+  const resolved = resolveVarReferences(dryVars, allVars);
+  const infoIssues = [];
+  for (const [name, entry] of resolved) {
+    if (/^var\(\s*--/.test(entry.resolved) && entry.resolved === entry.original) {
+      const varRefMatch = entry.original.match(/var\(\s*(--[a-zA-Z0-9-]+)/);
+      const refName = varRefMatch ? varRefMatch[1] : "unknown";
+      infoIssues.push({
+        severity: "info",
+        code: "unresolvable-var",
+        variable: name,
+        value: entry.original,
+        message: `${name} references ${refName} which is not defined in this CSS — type and contrast checks skipped`,
+        fix: null
+      });
+    }
+  }
+  const tier1 = checkMissingTokens(resolved);
+  const tier2 = checkValueTypes(resolved);
+  const tier3 = checkContrastHeuristics(resolved);
+  const tier4 = checkComponentTokens(resolved, spec);
+  const darkSchemeIssues = dryVars.size === 0 ? detectDarkScheme(css, allVars) : [];
+  const allIssues = [...tier1, ...tier2, ...tier3, ...tier4, ...darkSchemeIssues, ...infoIssues];
+  const severityOrder = { error: 0, warning: 1, info: 2 };
+  allIssues.sort((a, b) => (severityOrder[a.severity] ?? 2) - (severityOrder[b.severity] ?? 2));
+  const errors = allIssues.filter((i) => i.severity === "error").length;
+  const warnings = allIssues.filter((i) => i.severity === "warning").length;
+  const infos = allIssues.filter((i) => i.severity === "info").length;
+  const summary = allIssues.length === 0 ? "No issues found" : `${errors} error${errors !== 1 ? "s" : ""}, ${warnings} warning${warnings !== 1 ? "s" : ""}, ${infos} info`;
+  const found = dryVars.size;
+  const requiredSet = new Set(REQUIRED_TOKENS);
+  const requiredFound = [...dryVars.keys()].filter((k) => requiredSet.has(k)).length;
+  const extra = found - requiredFound;
+  return {
+    variables: { found, required: requiredFound, extra },
+    issues: allIssues,
+    summary
+  };
+}
+
+// src/project-planner.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+var DIR_OVERRIDES = {
+  QRCode: "qr-code"
+};
+function componentDir(name) {
+  return DIR_OVERRIDES[name] ?? name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function resolveStart(inputPath) {
+  const candidate = resolve(inputPath ?? process.cwd());
+  return existsSync(candidate) && statSync(candidate).isFile() ? dirname(candidate) : candidate;
+}
+function findUp(start, fileName) {
+  let current = start;
+  while (true) {
+    const candidate = resolve(current, fileName);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function findUpAny(start, fileNames) {
+  let current = start;
+  while (true) {
+    for (const fileName of fileNames) {
+      const candidate = resolve(current, fileName);
+      if (existsSync(candidate))
+        return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function detectPackageManager(root) {
+  if (!root)
+    return "unknown";
+  const lockfilePath = findUpAny(root, [
+    "bun.lock",
+    "bun.lockb",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock"
+  ]);
+  if (!lockfilePath)
+    return "unknown";
+  if (lockfilePath.endsWith("bun.lock") || lockfilePath.endsWith("bun.lockb"))
+    return "bun";
+  if (lockfilePath.endsWith("pnpm-lock.yaml"))
+    return "pnpm";
+  if (lockfilePath.endsWith("package-lock.json"))
+    return "npm";
+  if (lockfilePath.endsWith("yarn.lock"))
+    return "yarn";
+  return "unknown";
+}
+function readPackageJson(packageJsonPath) {
+  if (!packageJsonPath)
+    return null;
+  return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+}
+function getDependencyNames(pkg) {
+  return new Set([
+    ...Object.keys(pkg?.dependencies ?? {}),
+    ...Object.keys(pkg?.devDependencies ?? {})
+  ]);
+}
+function detectFramework(dependencyNames) {
+  if (dependencyNames.has("@sveltejs/kit"))
+    return "sveltekit";
+  if (dependencyNames.has("svelte"))
+    return "svelte";
+  return "unknown";
+}
+function hasImport(filePath, importPath) {
+  if (!filePath)
+    return false;
+  return readFileSync(filePath, "utf-8").includes(importPath);
+}
+function hasThemeAuto(appHtmlPath) {
+  if (!appHtmlPath)
+    return false;
+  return readFileSync(appHtmlPath, "utf-8").includes("theme-auto");
+}
+function hasAnyImport(filePaths, importPath) {
+  return filePaths.some((filePath) => hasImport(filePath, importPath));
+}
+function importsAppCss(rootLayoutPath) {
+  if (!rootLayoutPath)
+    return false;
+  const content = readFileSync(rootLayoutPath, "utf-8");
+  return content.includes("app.css");
+}
+function buildStatus(framework, hasPackageJson, stepsNeeded) {
+  if (!hasPackageJson || framework === "unknown")
+    return "unsupported";
+  return stepsNeeded === 0 ? "ready" : "partial";
+}
+function installCommand(packageManager) {
+  switch (packageManager) {
+    case "bun":
+      return "bun add @dryui/ui";
+    case "pnpm":
+      return "pnpm add @dryui/ui";
+    case "yarn":
+      return "yarn add @dryui/ui";
+    default:
+      return "npm install @dryui/ui";
+  }
+}
+function buildThemeImportSnippet(spec) {
+  return [
+    '<script lang="ts">',
+    `  import '${spec.themeImports.default}';`,
+    `  import '${spec.themeImports.dark}';`,
+    "</script>"
+  ].join(`
+`);
+}
+function buildThemeImportCssSnippet(spec) {
+  return [`@import '${spec.themeImports.default}';`, `@import '${spec.themeImports.dark}';`].join(`
+`);
+}
+function getSuggestedTarget(root, explicitTarget) {
+  if (explicitTarget)
+    return resolve(root ?? process.cwd(), explicitTarget);
+  if (!root)
+    return null;
+  const rootPage = resolve(root, "src/routes/+page.svelte");
+  return existsSync(rootPage) ? rootPage : null;
+}
+function getImportStatement(name, component, subpath = false) {
+  if (subpath && component.import === "@dryui/ui") {
+    return `import { ${name} } from '${component.import}/${componentDir(name)}';`;
+  }
+  return `import { ${name} } from '${component.import}';`;
+}
+function findComponent(spec, query) {
+  const exact = spec.components[query];
+  if (exact)
+    return { name: query, def: exact };
+  const lower = query.toLowerCase();
+  for (const [name, def] of Object.entries(spec.components)) {
+    if (name.toLowerCase() === lower)
+      return { name, def };
+  }
+  return null;
+}
+function detectProject(spec, inputPath) {
+  const start = resolveStart(inputPath);
+  const packageJsonPath = findUp(start, "package.json");
+  const root = packageJsonPath ? dirname(packageJsonPath) : null;
+  const dependencyNames = getDependencyNames(readPackageJson(packageJsonPath));
+  const framework = detectFramework(dependencyNames);
+  const appHtmlPath = root ? resolve(root, "src/app.html") : null;
+  const appCssPath = root ? resolve(root, "src/app.css") : null;
+  const rootLayoutPath = root ? resolve(root, "src/routes/+layout.svelte") : null;
+  const rootPagePath = root ? resolve(root, "src/routes/+page.svelte") : null;
+  const appHtml = appHtmlPath && existsSync(appHtmlPath) ? appHtmlPath : null;
+  const appCss = appCssPath && existsSync(appCssPath) ? appCssPath : null;
+  const rootLayout = rootLayoutPath && existsSync(rootLayoutPath) ? rootLayoutPath : null;
+  const rootPage = rootPagePath && existsSync(rootPagePath) ? rootPagePath : null;
+  const themeImportFiles = rootLayout && importsAppCss(rootLayout) ? [rootLayout, appCss] : [rootLayout];
+  const defaultImported = hasAnyImport(themeImportFiles, spec.themeImports.default);
+  const darkImported = hasAnyImport(themeImportFiles, spec.themeImports.dark);
+  const stepsNeeded = Number(!dependencyNames.has("@dryui/ui")) + Number(!defaultImported) + Number(!darkImported) + Number(!(appHtml && hasThemeAuto(appHtml)));
+  const warnings = [];
+  if (!packageJsonPath)
+    warnings.push("No package.json found above the provided path.");
+  if (framework === "unknown")
+    warnings.push("DryUI planning currently targets Svelte and SvelteKit projects.");
+  return {
+    inputPath: start,
+    root,
+    packageJsonPath,
+    framework,
+    packageManager: detectPackageManager(root),
+    status: buildStatus(framework, Boolean(packageJsonPath), stepsNeeded),
+    dependencies: {
+      ui: dependencyNames.has("@dryui/ui"),
+      primitives: dependencyNames.has("@dryui/primitives")
+    },
+    files: {
+      appHtml,
+      appCss,
+      rootLayout,
+      rootPage
+    },
+    theme: {
+      defaultImported,
+      darkImported,
+      themeAuto: hasThemeAuto(appHtml)
+    },
+    warnings
+  };
+}
+function planInstall(spec, inputPath) {
+  const detection = detectProject(spec, inputPath);
+  const steps = [];
+  if (detection.status === "unsupported") {
+    steps.push({
+      kind: "blocked",
+      status: "blocked",
+      title: "Project detection incomplete",
+      description: detection.warnings.join(" ") || "DryUI install planning requires a Svelte or SvelteKit project with a package.json."
+    });
+    return { detection, steps };
+  }
+  if (!detection.dependencies.ui) {
+    steps.push({
+      kind: "install-package",
+      status: "pending",
+      title: "Install @dryui/ui",
+      description: "Add the styled DryUI package to the current project.",
+      command: installCommand(detection.packageManager)
+    });
+  }
+  if (!detection.theme.defaultImported || !detection.theme.darkImported) {
+    if (detection.files.appCss && detection.files.rootLayout && importsAppCss(detection.files.rootLayout)) {
+      steps.push({
+        kind: "edit-file",
+        status: "pending",
+        title: "Add theme imports to app.css",
+        description: "Ensure the app-level stylesheet imports both default and dark DryUI themes.",
+        path: detection.files.appCss,
+        snippet: buildThemeImportCssSnippet(spec)
+      });
+    } else if (!detection.files.rootLayout) {
+      const path = detection.root ? resolve(detection.root, "src/routes/+layout.svelte") : null;
+      steps.push({
+        kind: "create-file",
+        status: "pending",
+        title: "Create root layout with theme imports",
+        description: "Create src/routes/+layout.svelte and add the required DryUI theme imports.",
+        ...path ? { path } : {},
+        snippet: buildThemeImportSnippet(spec)
+      });
+    } else {
+      steps.push({
+        kind: "edit-file",
+        status: "pending",
+        title: "Add theme imports to the root layout",
+        description: "Ensure the root layout imports both default and dark DryUI themes.",
+        path: detection.files.rootLayout,
+        snippet: buildThemeImportSnippet(spec)
+      });
+    }
+  }
+  if (!detection.files.appHtml) {
+    steps.push({
+      kind: "blocked",
+      status: "blocked",
+      title: "app.html not found",
+      description: "DryUI expects src/app.html so the document can default to theme-auto mode."
+    });
+  } else if (!detection.theme.themeAuto) {
+    steps.push({
+      kind: "edit-file",
+      status: "pending",
+      title: "Set html theme mode to auto",
+      description: 'Add class="theme-auto" to the html element in src/app.html.',
+      path: detection.files.appHtml,
+      snippet: '<html class="theme-auto">'
+    });
+  }
+  if (steps.length === 0) {
+    steps.push({
+      kind: "note",
+      status: "done",
+      title: "DryUI install plan is complete",
+      description: "The project already has @dryui/ui, theme imports, and theme-auto configured."
+    });
+  }
+  return { detection, steps };
+}
+function planAdd(spec, query, options = {}) {
+  const installPlan = planInstall(spec, options.cwd);
+  const component = findComponent(spec, query);
+  if (component) {
+    const target = getSuggestedTarget(installPlan.detection.root, options.target);
+    const steps = [];
+    const warnings = [...installPlan.detection.warnings];
+    if (installPlan.steps.some((step) => step.status === "pending" || step.status === "blocked")) {
+      steps.push({
+        kind: "note",
+        status: "info",
+        title: "Complete install plan first",
+        description: "Apply the install plan before inserting DryUI components into project files."
+      });
+    }
+    steps.push(target ? {
+      kind: "edit-file",
+      status: "pending",
+      title: "Insert component into the target file",
+      description: "Add the import and snippet below to the chosen Svelte file.",
+      path: target,
+      snippet: `${getImportStatement(component.name, component.def, options.subpath)}
+
+${component.def.example}`
+    } : {
+      kind: "note",
+      status: "info",
+      title: "Choose a target Svelte file",
+      description: "No root page was found. Pick a target file and reuse the import and snippet in this plan."
+    });
+    return {
+      detection: installPlan.detection,
+      installPlan,
+      targetType: "component",
+      name: component.name,
+      importStatement: getImportStatement(component.name, component.def, options.subpath),
+      snippet: component.def.example,
+      target,
+      steps,
+      warnings
+    };
+  }
+  throw new Error(`Unknown component: "${query}"`);
+}
+
+// src/workspace-audit.ts
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, realpathSync, statSync as statSync2 } from "node:fs";
+import { dirname as dirname2, relative, resolve as resolve2 } from "node:path";
+var DEFAULT_INCLUDE = [
+  "packages/ui",
+  "packages/primitives",
+  "apps/docs",
+  "apps/playground"
+];
+var DEFAULT_EXCLUDED_SEGMENTS = new Set([
+  ".git",
+  ".svelte-kit",
+  "__fixtures__",
+  "build",
+  "coverage",
+  "dist",
+  "fixtures",
+  "node_modules",
+  "reports",
+  "test",
+  "tests"
+]);
+var DEFAULT_EXCLUDED_PATHS = new Set([
+  "apps/studio",
+  "packages/canvas",
+  "packages/hand-tracking",
+  "packages/studio-server"
+]);
+var MAX_SEVERITY = { info: 0, warning: 1, error: 2 };
+function normalizePath(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\/+/, "");
+}
+function resolveRoot(inputPath) {
+  const candidate = resolve2(inputPath ?? process.cwd());
+  if (existsSync2(candidate) && statSync2(candidate).isFile()) {
+    return dirname2(candidate);
+  }
+  return candidate;
+}
+function hasGlob(pattern) {
+  return /[*?[{]/.test(pattern);
+}
+function matchesPattern(path, pattern) {
+  const normalizedPath = normalizePath(path);
+  const normalizedPattern = normalizePath(pattern).replace(/\/+$/, "");
+  if (!normalizedPattern || normalizedPattern === ".")
+    return true;
+  if (!hasGlob(normalizedPattern)) {
+    return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+  }
+  const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${escaped}$`).test(normalizedPath);
+}
+function collectFiles(root, current = root) {
+  const files = [];
+  for (const entry of readdirSync(current, { withFileTypes: true })) {
+    const absPath = resolve2(current, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".git")
+        continue;
+      files.push(...collectFiles(root, absPath));
+      continue;
+    }
+    if (!entry.isFile())
+      continue;
+    files.push(normalizePath(relative(root, absPath)));
+  }
+  return files;
+}
+function collectChangedFiles(root) {
+  try {
+    execFileSync("git", ["-C", root, "rev-parse", "--verify", "HEAD"], { stdio: "ignore" });
+    const canonicalRoot = realpathSync.native(root);
+    const repoRoot = realpathSync.native(execFileSync("git", ["-C", root, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim());
+    const files = new Set;
+    const outputs = [
+      execFileSync("git", ["-C", repoRoot, "diff", "--name-only", "HEAD", "--"], {
+        encoding: "utf8"
+      }),
+      execFileSync("git", ["-C", repoRoot, "diff", "--name-only", "--cached", "HEAD", "--"], {
+        encoding: "utf8"
+      }),
+      execFileSync("git", ["-C", repoRoot, "ls-files", "--others", "--exclude-standard"], {
+        encoding: "utf8"
+      })
+    ];
+    for (const output of outputs) {
+      for (const line of output.split(`
+`)) {
+        const changedPath = line.trim();
+        if (!changedPath)
+          continue;
+        const absPath = resolve2(repoRoot, changedPath);
+        const relativePath = normalizePath(relative(canonicalRoot, absPath));
+        if (relativePath.startsWith(".."))
+          continue;
+        files.add(relativePath);
+      }
+    }
+    return files;
+  } catch {
+    throw new Error("The --changed option requires a Git repository with an existing HEAD commit.");
+  }
+}
+function defaultInclude(root) {
+  const included = DEFAULT_INCLUDE.filter((entry) => existsSync2(resolve2(root, entry)));
+  return included.length > 0 ? included : ["."];
+}
+function isDefaultExcluded(path) {
+  const normalized = normalizePath(path);
+  if (normalized.endsWith(".d.ts") || normalized.endsWith(".svelte.d.ts"))
+    return true;
+  if (DEFAULT_EXCLUDED_PATHS.has(normalized))
+    return true;
+  const segments = normalized.split("/");
+  return segments.some((segment) => DEFAULT_EXCLUDED_SEGMENTS.has(segment));
+}
+function shouldScanFile(path, include, exclude, changedFiles, explicitInclude) {
+  const normalized = normalizePath(path);
+  const included = include.length > 0 ? include.some((pattern) => matchesPattern(normalized, pattern)) : DEFAULT_INCLUDE.some((pattern) => matchesPattern(normalized, pattern));
+  if (!included)
+    return false;
+  if (!explicitInclude && isDefaultExcluded(normalized))
+    return false;
+  if (exclude.some((pattern) => matchesPattern(normalized, pattern)))
+    return false;
+  if (changedFiles && !matchesChangedFile(normalized, changedFiles))
+    return false;
+  return true;
+}
+function matchesChangedFile(path, changedFiles) {
+  const normalized = normalizePath(path);
+  for (const changed of changedFiles) {
+    if (changed === normalized)
+      return true;
+    if (changed.endsWith(`/${normalized}`))
+      return true;
+    if (normalized.endsWith(`/${changed}`))
+      return true;
+  }
+  return false;
+}
+function severityAtOrAbove(severity, maxSeverity) {
+  if (!maxSeverity)
+    return true;
+  return MAX_SEVERITY[severity] >= MAX_SEVERITY[maxSeverity];
+}
+function compareFindings(left, right) {
+  const severityDelta = MAX_SEVERITY[right.severity] - MAX_SEVERITY[left.severity];
+  if (severityDelta !== 0)
+    return severityDelta;
+  const fileDelta = left.file.localeCompare(right.file);
+  if (fileDelta !== 0)
+    return fileDelta;
+  const lineDelta = (left.line ?? Number.MAX_SAFE_INTEGER) - (right.line ?? Number.MAX_SAFE_INTEGER);
+  if (lineDelta !== 0)
+    return lineDelta;
+  return left.ruleId.localeCompare(right.ruleId);
+}
+function toFinding(file, line, ruleId, severity, message, fix) {
+  return {
+    file,
+    line,
+    column: null,
+    ruleId,
+    severity,
+    fixable: fix !== null,
+    message,
+    suggestedFixes: fix ? [{ description: "Apply suggested fix", replacement: fix }] : []
+  };
+}
+function projectFindings(root, packageJsonPath, spec) {
+  const result = detectProject(spec, packageJsonPath);
+  const findings = [];
+  const warnings = [...result.warnings];
+  const packageFile = normalizePath(relative(root, packageJsonPath));
+  if (result.framework === "unknown") {
+    return { findings, project: result, warnings };
+  }
+  if (!result.dependencies.ui) {
+    findings.push(toFinding(packageFile, null, "project/missing-ui-dependency", "error", "Install @dryui/ui before using DryUI components.", "bun add @dryui/ui"));
+  }
+  if (!result.theme.defaultImported || !result.theme.darkImported) {
+    const targetPath = result.files.appCss ?? result.files.rootLayout ?? result.files.appHtml ?? packageJsonPath;
+    findings.push(toFinding(normalizePath(relative(root, targetPath)), null, "project/missing-theme-import", "error", "Add both DryUI theme imports to the app shell.", `import '${spec.themeImports.default}';
+import '${spec.themeImports.dark}';`));
+  }
+  if (!result.theme.themeAuto) {
+    const targetPath = result.files.appHtml ?? packageJsonPath;
+    findings.push(toFinding(normalizePath(relative(root, targetPath)), null, "project/missing-theme-auto", "error", "Set the root html element to theme-auto mode.", '<html class="theme-auto">'));
+  }
+  return { findings, project: result, warnings };
+}
+function reviewFindings(root, filePath, content, spec) {
+  const result = reviewComponent(content, spec, normalizePath(relative(root, filePath)));
+  return result.issues.map((issue) => toFinding(normalizePath(relative(root, filePath)), issue.line, `component/${issue.code}`, issue.severity === "suggestion" ? "info" : issue.severity, issue.message, issue.fix));
+}
+function themeFindings(root, filePath, content, spec) {
+  const result = diagnoseTheme(content, spec);
+  return result.issues.map((issue) => toFinding(normalizePath(relative(root, filePath)), null, `theme/${issue.code}`, issue.severity, issue.message, issue.fix));
+}
+function buildWorkspaceReport(spec, options = {}) {
+  const root = resolveRoot(options.cwd);
+  const explicitInclude = Boolean(options.include?.length);
+  const include = explicitInclude ? [...options.include ?? []] : defaultInclude(root);
+  const exclude = options.exclude ? [...options.exclude] : [];
+  const files = collectFiles(root);
+  const changed = options.changed ?? false;
+  const changedFiles = changed ? collectChangedFiles(root) : null;
+  const findings = [];
+  const projects = [];
+  const warnings = [];
+  if (!options.include?.length && include.every((entry) => DEFAULT_INCLUDE.includes(entry))) {
+    warnings.push("Using the default DryUI workspace scan scope and excluding experimental packages.");
+  }
+  if (changed) {
+    warnings.push("Scanning only modified, staged, and untracked files relative to the current HEAD.");
+  }
+  const scannedFiles = files.filter((file) => shouldScanFile(file, include, exclude, changedFiles, explicitInclude)).length;
+  const skippedFiles = files.length - scannedFiles;
+  for (const file of files) {
+    if (!shouldScanFile(file, include, exclude, changedFiles, explicitInclude))
+      continue;
+    const absPath = resolve2(root, file);
+    const content = readFileSync2(absPath, "utf8");
+    if (file.endsWith("package.json")) {
+      try {
+        const parsed = JSON.parse(content);
+        const dependencyNames = new Set([
+          ...Object.keys(parsed.dependencies ?? {}),
+          ...Object.keys(parsed.devDependencies ?? {})
+        ]);
+        if (dependencyNames.has("svelte") || dependencyNames.has("@sveltejs/kit")) {
+          const project = projectFindings(root, absPath, spec);
+          projects.push(project.project);
+          findings.push(...project.findings);
+          warnings.push(...project.warnings);
+        }
+      } catch {
+        findings.push(toFinding(file, null, "workspace/invalid-package-json", "warning", "Package metadata could not be parsed.", null));
+      }
+      continue;
+    }
+    if (file.endsWith(".svelte") && (content.includes("@dryui/ui") || content.includes("@dryui/primitives"))) {
+      findings.push(...reviewFindings(root, absPath, content, spec));
+      continue;
+    }
+    if (file.endsWith(".css") && content.includes("--dry-")) {
+      findings.push(...themeFindings(root, absPath, content, spec));
+    }
+  }
+  const filteredFindings = findings.filter((finding) => severityAtOrAbove(finding.severity, options.maxSeverity)).sort(compareFindings);
+  const summary = filteredFindings.reduce((acc, finding) => {
+    acc[finding.severity] += 1;
+    acc.byRule[finding.ruleId] = (acc.byRule[finding.ruleId] ?? 0) + 1;
+    return acc;
+  }, { error: 0, warning: 0, info: 0, byRule: {} });
+  return {
+    root,
+    projects,
+    scope: {
+      include,
+      exclude,
+      changed
+    },
+    scannedFiles,
+    skippedFiles,
+    findings: filteredFindings,
+    warnings,
+    summary
+  };
+}
+function scanWorkspace(spec, options = {}) {
+  return buildWorkspaceReport(spec, options);
+}
+export {
+  scanWorkspace,
+  buildWorkspaceReport
+};