@maz-ui/mcp 5.1.1 → 5.2.0-beta.0

package/dist/shared/mcp.cBFLVChV.mjs

@@ -1,3002 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { join, dirname, resolve, isAbsolute, relative } from 'node:path';
-import { parseArgs } from 'node:util';
-import { findProjectPackage, readPackageVersion, AGENT_TARGETS, detectAgentTargets, setupAgents } from '@maz-ui/node';
-import { getErrorMessage } from '@maz-ui/utils/helpers/getErrorMessage';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { z } from 'zod';
-import MiniSearch from 'minisearch';
-import { NodeTypes, parse } from '@vue/compiler-dom';
-import { glob, globSync } from 'tinyglobby';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { execFileSync } from 'node:child_process';
-import { parse as parse$1 } from '@babel/parser';
-
-function readOwnVersion(from = dirname(fileURLToPath(import.meta.url))) {
-  let directory = from;
-  for (; ; ) {
-    const file = join(directory, "package.json");
-    if (existsSync(file)) {
-      const { name, version } = JSON.parse(readFileSync(file, "utf8"));
-      if (name === "@maz-ui/mcp" && version)
-        return version;
-    }
-    const parent = dirname(directory);
-    if (parent === directory)
-      return "0.0.0";
-    directory = parent;
-  }
-}
-
-const SUPPORTED_SCHEMA_VERSION = 1;
-const docCategories = ["guide", "component", "composable", "directive", "plugin", "ecosystem", "util", "node", "reference"];
-const namedTokenSchema = z.object({ name: z.string(), value: z.string() });
-const docEntrySchema = z.object({
-  id: z.string(),
-  category: z.enum(docCategories),
-  slug: z.string(),
-  title: z.string(),
-  description: z.string(),
-  package: z.string(),
-  file: z.string(),
-  url: z.string().optional(),
-  symbols: z.array(z.string()),
-  imports: z.array(z.string()),
-  aliases: z.array(z.string()),
-  headings: z.array(z.string()),
-  related: z.array(z.string()),
-  chars: z.number()
-});
-const propApiSchema = z.object({
-  name: z.string(),
-  type: z.string(),
-  description: z.string().optional(),
-  required: z.boolean(),
-  default: z.string().optional(),
-  values: z.array(z.string()).optional(),
-  strictValues: z.boolean(),
-  model: z.string().optional()
-});
-const componentApiSchema = z.object({
-  name: z.string(),
-  docId: z.string(),
-  description: z.string().optional(),
-  import: z.string(),
-  parent: z.string().optional(),
-  props: z.array(propApiSchema),
-  events: z.array(z.object({ name: z.string(), description: z.string().optional(), payload: z.string().optional() })),
-  slots: z.array(z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    bindings: z.array(z.object({ name: z.string(), type: z.string().optional(), description: z.string().optional() }))
-  })),
-  expose: z.array(z.object({ name: z.string(), description: z.string().optional() }))
-});
-const tailwindSchema = z.object({
-  entries: z.array(z.object({ path: z.string(), description: z.string() })),
-  colors: z.array(z.object({
-    name: z.string(),
-    variable: z.string(),
-    foreground: z.boolean(),
-    scale: z.array(z.string()),
-    usage: z.string()
-  })),
-  radius: z.array(namedTokenSchema),
-  shadows: z.array(namedTokenSchema),
-  breakpoints: z.array(namedTokenSchema),
-  zIndex: z.array(namedTokenSchema),
-  fonts: z.array(namedTokenSchema),
-  durations: z.array(namedTokenSchema),
-  easings: z.array(namedTokenSchema),
-  spacing: z.array(namedTokenSchema),
-  utilities: z.array(z.object({ name: z.string(), css: z.string() })),
-  variants: z.array(namedTokenSchema),
-  containerVariables: z.array(namedTokenSchema),
-  transitions: z.array(z.string())
-});
-const manifestSchema = z.object({
-  schemaVersion: z.literal(SUPPORTED_SCHEMA_VERSION),
-  name: z.literal("maz-ui"),
-  version: z.string(),
-  homepage: z.string(),
-  packages: z.array(z.object({ name: z.string(), description: z.string(), docId: z.string() })),
-  docs: z.array(docEntrySchema),
-  components: z.array(componentApiSchema),
-  icons: z.object({ package: z.string(), names: z.array(z.string()) }),
-  tailwind: tailwindSchema
-});
-
-class Knowledge {
-  /**
-   * @param manifest manifest of the docs bundle
-   * @param source where the bundle was found
-   * @param documentedVersion version of the documented maz-ui, read from a package.json at runtime when possible: the
-   * docs are generated before the release bumps the version, so `manifest.version` can be the previous one
-   */
-  constructor(manifest, source, documentedVersion = manifest.version) {
-    this.manifest = manifest;
-    this.source = source;
-    this.documentedVersion = documentedVersion;
-    this.docsById = new Map(manifest.docs.map((doc) => [doc.id, doc]));
-    this.componentsByName = new Map(manifest.components.map((component) => [component.name, component]));
-    this.iconNames = new Set(manifest.icons.names);
-  }
-  docsById;
-  componentsByName;
-  iconNames;
-  cache = /* @__PURE__ */ new Map();
-  get version() {
-    return this.documentedVersion;
-  }
-  get docs() {
-    return this.manifest.docs;
-  }
-  readDoc(id) {
-    const cached = this.cache.get(id);
-    if (cached !== void 0)
-      return cached;
-    const doc = this.docsById.get(id);
-    if (!doc)
-      throw new Error(`Unknown doc "${id}"`);
-    const content = readFileSync(join(this.source.directory, doc.file), "utf8");
-    this.cache.set(id, content);
-    return content;
-  }
-  readFile(relativePath) {
-    const file = join(this.source.directory, relativePath);
-    return existsSync(file) ? readFileSync(file, "utf8") : void 0;
-  }
-}
-function defaultBundledDir() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const candidates = [resolve(here, "../docs"), resolve(here, "../../docs")];
-  return candidates.find((candidate) => existsSync(join(candidate, "manifest.json"))) ?? candidates[0];
-}
-function readManifest(directory) {
-  const file = join(directory, "manifest.json");
-  if (!existsSync(file))
-    return void 0;
-  const parsed = manifestSchema.safeParse(JSON.parse(readFileSync(file, "utf8")));
-  return parsed.success ? parsed.data : void 0;
-}
-function findProjectMazUi(cwd) {
-  const directory = findProjectPackage(cwd, "maz-ui");
-  return directory ? { directory, version: readPackageVersion(directory) ?? "0.0.0" } : void 0;
-}
-function loadKnowledge(options = {}) {
-  const explicit = options.docsDir ?? process.env.MAZ_UI_DOCS_DIR;
-  if (explicit) {
-    const manifest2 = readManifest(explicit);
-    if (!manifest2)
-      throw new Error(`No valid maz-ui docs bundle (manifest.json) in ${explicit}`);
-    return new Knowledge(manifest2, { kind: "custom", directory: explicit }, readPackageVersion(dirname(explicit)) ?? manifest2.version);
-  }
-  const project = findProjectMazUi(options.cwd ?? process.cwd());
-  if (project) {
-    const directory = join(project.directory, "docs");
-    const manifest2 = readManifest(directory);
-    if (manifest2)
-      return new Knowledge(manifest2, { kind: "project", directory, projectVersion: project.version }, project.version);
-  }
-  const bundledDir = options.bundledDir ?? defaultBundledDir();
-  const manifest = readManifest(bundledDir);
-  if (!manifest)
-    throw new Error(`The docs bundle of @maz-ui/mcp is missing or invalid (${bundledDir}). Reinstall the package.`);
-  return new Knowledge(manifest, { kind: "bundled", directory: bundledDir, projectVersion: project?.version }, options.bundledVersion ?? readOwnVersion());
-}
-
-const CATEGORY_PRIORITY = ["component", "composable", "directive", "plugin", "util", "guide", "ecosystem", "reference", "node"];
-function toKebab(value) {
-  return value.replaceAll(/([a-z\d])([A-Z])/g, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
-}
-function normalizeName(value) {
-  return value.trim().replace(/^<\/?|\s*\/?>$/g, "").replace(/^https?:\/\/(?:www\.)?maz-ui\.com\//, "").replace(/^maz-ui:\/\//, "").replace(/^([a-z]+):\/\//, "$1s/").replace(/\.md$/, "").replace(/\/$/, "");
-}
-function byPriority(a, b) {
-  return CATEGORY_PRIORITY.indexOf(a.category) - CATEGORY_PRIORITY.indexOf(b.category);
-}
-function resolveDoc(knowledge, query, category) {
-  const name = normalizeName(query);
-  const lower = name.toLowerCase();
-  const kebab = toKebab(name);
-  const candidates = knowledge.docs;
-  const pick = (predicate) => candidates.filter(predicate).sort(byPriority)[0];
-  const byId = knowledge.docsById.get(name);
-  if (byId && (true))
-    return byId;
-  const pathMatch = lower.includes("/") ? pick((doc) => doc.id.toLowerCase() === lower || doc.id.toLowerCase().endsWith(`/${lower}`)) : void 0;
-  return pathMatch ?? pick((doc) => doc.symbols.includes(name)) ?? pick((doc) => doc.symbols.some((symbol) => symbol.toLowerCase() === lower)) ?? pick((doc) => doc.slug === lower || doc.slug === kebab) ?? pick((doc) => doc.slug === `maz-${kebab}` || doc.slug === kebab.replace(/^v-/, "") || doc.slug === `use-${kebab}`) ?? pick((doc) => doc.title.toLowerCase() === lower) ?? (lower.includes("/") ? resolveDoc(knowledge, lower.split("/").at(-1)) : void 0);
-}
-function resolveComponent(knowledge, query) {
-  const name = normalizeName(query).replace(/^components\//, "");
-  const exact = knowledge.componentsByName.get(name);
-  if (exact)
-    return exact;
-  const kebab = toKebab(name).replace(/^maz-/, "");
-  for (const component of knowledge.manifest.components) {
-    if (toKebab(component.name).replace(/^maz-/, "") === kebab)
-      return component;
-  }
-  return void 0;
-}
-function editDistance(a, b, max = 3) {
-  if (Math.abs(a.length - b.length) > max)
-    return max + 1;
-  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (let i = 1; i <= a.length; i++) {
-    const current = [i];
-    let rowMin = i;
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
-      rowMin = Math.min(rowMin, current[j]);
-    }
-    if (rowMin > max)
-      return max + 1;
-    previous = current;
-  }
-  return previous[b.length];
-}
-function closest(value, candidates, { max = 3, limit = 3 } = {}) {
-  const lower = value.toLowerCase();
-  return [...candidates].map((candidate) => ({ candidate, distance: editDistance(lower, candidate.toLowerCase(), max) })).filter(({ distance }) => distance <= max).sort((a, b) => a.distance - b.distance || a.candidate.length - b.candidate.length).slice(0, limit).map(({ candidate }) => candidate);
-}
-
-const SYNONYMS = {
-  modal: ["dialog"],
-  popup: ["dialog", "popover"],
-  lightbox: ["dialog", "fullscreen"],
-  confirmation: ["confirm"],
-  notification: ["toast"],
-  notify: ["toast"],
-  snackbar: ["toast"],
-  flash: ["toast"],
-  loader: ["spinner", "loading"],
-  loading: ["spinner", "skeleton", "wait"],
-  shimmer: ["skeleton"],
-  placeholder: ["skeleton"],
-  combobox: ["select"],
-  autocomplete: ["select"],
-  multiselect: ["select"],
-  picker: ["select"],
-  datepicker: ["date"],
-  calendar: ["date"],
-  datetime: ["date", "time"],
-  picture: ["avatar", "image"],
-  photo: ["avatar", "image", "gallery"],
-  profile: ["avatar"],
-  img: ["image"],
-  upload: ["dropzone"],
-  file: ["dropzone"],
-  toggle: ["switch"],
-  checkbox: ["checkbox"],
-  wizard: ["stepper"],
-  step: ["stepper"],
-  grid: ["table"],
-  datagrid: ["table"],
-  datatable: ["table"],
-  menu: ["dropdown"],
-  nav: ["sidebar"],
-  navigation: ["sidebar", "tab"],
-  sidenav: ["sidebar"],
-  dark: ["theme"],
-  darkmode: ["theme"],
-  palette: ["theme", "color"],
-  token: ["tailwind", "theme"],
-  css: ["tailwind"],
-  class: ["tailwind"],
-  classname: ["tailwind"],
-  color: ["tailwind", "theme"],
-  i18n: ["translation"],
-  translate: ["translation"],
-  locale: ["translation"],
-  language: ["translation"],
-  tel: ["phone"],
-  telephone: ["phone"],
-  money: ["currency", "price"],
-  price: ["currency"],
-  otp: ["code"],
-  pin: ["code"],
-  validation: ["validator"],
-  validate: ["validator"],
-  schema: ["validator"],
-  zod: ["validator"],
-  valibot: ["validator"],
-  hint: ["tooltip"],
-  hover: ["tooltip", "popover"],
-  hovering: ["tooltip", "popover"],
-  typing: ["debounce"],
-  keystroke: ["debounce"],
-  temporary: ["toast"],
-  message: ["toast", "alert"],
-  localized: ["format"],
-  display: ["format"],
-  chip: ["badge", "tag"],
-  pill: ["badge"],
-  label: ["badge"],
-  collapse: ["accordion", "expand"],
-  collapsible: ["accordion"],
-  marquee: ["ticker"],
-  slideshow: ["carousel"],
-  gesture: ["swipe", "drag"],
-  inactivity: ["idle"],
-  afk: ["idle"],
-  responsive: ["breakpoint"],
-  viewport: ["window", "breakpoint"],
-  mobile: ["breakpoint"],
-  clipboard: ["copy"],
-  slug: ["kebab", "normalize"],
-  delay: ["debounce", "sleep"],
-  wait: ["sleep", "wait"],
-  trash: ["delete"],
-  install: ["getting", "started", "setup"],
-  setup: ["getting", "started", "install"],
-  autoimport: ["resolver", "nuxt"],
-  ai: ["agent", "mcp"],
-  llm: ["agent", "mcp"]
-};
-
-const STOPWORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "any",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "can",
-  "create",
-  "do",
-  "does",
-  "for",
-  "from",
-  "get",
-  "how",
-  "i",
-  "in",
-  "into",
-  "is",
-  "it",
-  "its",
-  "make",
-  "me",
-  "my",
-  "need",
-  "of",
-  "on",
-  "or",
-  "some",
-  "that",
-  "the",
-  "this",
-  "to",
-  "use",
-  "using",
-  "want",
-  "way",
-  "what",
-  "when",
-  "which",
-  "with",
-  "you",
-  "your",
-  "maz",
-  "ui",
-  "vue",
-  "nuxt"
-]);
-function stem(term) {
-  if (term.length <= 4 || /\d/.test(term))
-    return term;
-  if (term.endsWith("ies"))
-    return `${term.slice(0, -3)}y`;
-  if (/(?:ch|sh|x|ss)es$/.test(term))
-    return term.slice(0, -2);
-  if (term.endsWith("s") && !term.endsWith("ss") && !term.endsWith("us") && !term.endsWith("is"))
-    return term.slice(0, -1);
-  if (term.endsWith("ing") && term.length > 6)
-    return term.slice(0, -3);
-  if (term.endsWith("ed") && term.length > 5)
-    return term.slice(0, -2);
-  return term;
-}
-function tokenize(text) {
-  const tokens = [];
-  for (const word of text.split(/[^\w$-]+|_+/)) {
-    if (!word)
-      continue;
-    const parts = word.replaceAll(/([a-z])(\d)/gi, "$1 $2").replaceAll(/([a-z\d])([A-Z])/g, "$1 $2").replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s-]+/).filter(Boolean);
-    if (parts.length > 1)
-      tokens.push(word.replaceAll("-", ""));
-    tokens.push(...parts);
-  }
-  return tokens;
-}
-function processTerm(term) {
-  const lower = term.toLowerCase().replaceAll("$", "");
-  if (lower.length < 2 || STOPWORDS.has(lower))
-    return null;
-  return stem(lower);
-}
-function analyze(text) {
-  return tokenize(text).map(processTerm).filter((term) => term !== null);
-}
-
-const FIELD_BOOSTS = {
-  name: 8,
-  symbols: 3,
-  aliases: 5,
-  description: 2.5,
-  headings: 1.5,
-  api: 1.2,
-  body: 0.5
-};
-const CATEGORY_HINTS = {
-  component: "component",
-  composable: "composable",
-  hook: "composable",
-  directive: "directive",
-  plugin: "plugin",
-  helper: "util",
-  util: "util",
-  utility: "util",
-  function: "util",
-  guide: "guide"
-};
-const META_DOCS = /* @__PURE__ */ new Map([
-  ["guide/ai-agents", /\b(?:ai|agents?|llms?|claude|cursor|copilot|codex|mcp)\b/i],
-  ["ecosystem/mcp", /\b(?:ai|agents?|llms?|claude|cursor|copilot|codex|mcp)\b/i],
-  ["ecosystem/eslint-config", /\b(?:eslint|lint|linter|linting)\b/i],
-  ["ecosystem/stylelint-config", /\b(?:stylelint|lint|linter|linting)\b/i],
-  ["guide/migration-v5", /\b(?:migrat\w*|upgrad\w*|v4|v5|breaking)\b/i]
-]);
-const META_DOC_FACTOR = 0.15;
-const LOW_VALUE_TERMS = new Set(["add", "show", "display", "delete", "remove", "update", "set", "open", "close", "user", "users", "page", "item", "data", "value", "list", "text", "click", "between", "before", "after"].map((term) => processTerm(term) ?? term));
-const LOW_VALUE_FACTOR = 0.4;
-const LOW_VALUE_ONLY_FACTOR = 0.25;
-const EXACT_MATCH_BOOST = 4;
-const EXACT_ALIAS_BOOST = 4;
-const CATEGORY_HINT_BOOST = 1.4;
-function normalizedSynonyms() {
-  const map = /* @__PURE__ */ new Map();
-  for (const [key, values] of Object.entries(SYNONYMS)) {
-    const term = processTerm(key);
-    if (term)
-      map.set(term, values.map(processTerm).filter((value) => !!value && value !== term));
-  }
-  return map;
-}
-function bodyOf(markdown) {
-  return markdown.replace(/^---\n[\s\S]*?\n---\n/, "");
-}
-class DocSearch {
-  constructor(knowledge) {
-    this.knowledge = knowledge;
-    this.index = new MiniSearch({
-      fields: Object.keys(FIELD_BOOSTS),
-      storeFields: [],
-      tokenize,
-      processTerm
-    });
-    this.index.addAll(knowledge.docs.map((doc) => this.toIndexed(doc)));
-  }
-  index;
-  synonyms = normalizedSynonyms();
-  toIndexed(doc) {
-    const component = doc.category === "component" ? this.knowledge.componentsByName.get(doc.title) : void 0;
-    const api = component ? [
-      ...component.props.map((prop) => prop.name),
-      ...component.events.map((event) => event.name),
-      ...component.slots.map((slot) => slot.name)
-    ].join(" ") : "";
-    return {
-      id: doc.id,
-      name: [doc.title, doc.slug].join(" "),
-      symbols: doc.symbols.join(" "),
-      aliases: doc.aliases.join(" . "),
-      description: doc.description,
-      headings: doc.headings.join(" . "),
-      api,
-      body: bodyOf(this.knowledge.readDoc(doc.id))
-    };
-  }
-  exactMatch(query) {
-    const name = normalizeName(query);
-    const lower = name.toLowerCase();
-    const kebab = toKebab(name);
-    return this.knowledge.docs.find(
-      (doc) => doc.symbols.some((symbol) => symbol.toLowerCase() === lower) || doc.title.toLowerCase() === lower || doc.slug === lower || doc.slug === kebab || doc.id === lower || doc.slug === `maz-${kebab}`
-    );
-  }
-  search(query, { category, limit = 8 } = {}) {
-    const terms = analyze(query);
-    if (terms.length === 0)
-      return [];
-    const hintedCategory = category ? void 0 : terms.map((term) => CATEGORY_HINTS[term]).find(Boolean);
-    const expansion = [...new Set(terms.flatMap((term) => this.synonyms.get(term) ?? []))].filter((term) => !terms.includes(term));
-    const exact = this.exactMatch(query);
-    const normalizedQuery = query.trim().toLowerCase();
-    const hasValuableTerm = terms.some((term) => !LOW_VALUE_TERMS.has(term));
-    const results = this.index.search({
-      combineWith: "OR",
-      queries: [
-        { queries: [terms.join(" ")], combineWith: "OR", boostTerm: (term) => LOW_VALUE_TERMS.has(term) ? LOW_VALUE_FACTOR : 1 },
-        ...expansion.length > 0 ? [{ queries: [expansion.join(" ")], combineWith: "OR", boostTerm: () => 0.45 }] : []
-      ]
-    }, {
-      boost: FIELD_BOOSTS,
-      fuzzy: (term) => term.length >= 5 ? 0.2 : false,
-      prefix: (term) => term.length >= 4,
-      weights: { fuzzy: 0.35, prefix: 0.5 },
-      filter: (result) => !category || this.knowledge.docsById.get(result.id)?.category === category
-    });
-    return results.map((result) => {
-      const doc = this.knowledge.docsById.get(result.id);
-      const matched = terms.filter((term) => result.queryTerms.includes(term));
-      const coverage = matched.length / terms.length;
-      let score = result.score * (0.6 + coverage);
-      if (exact && doc.id === exact.id)
-        score *= EXACT_MATCH_BOOST;
-      else if (doc.aliases.includes(normalizedQuery))
-        score *= EXACT_ALIAS_BOOST;
-      if (hintedCategory && doc.category === hintedCategory)
-        score *= CATEGORY_HINT_BOOST;
-      if (hasValuableTerm && result.queryTerms.every((term) => LOW_VALUE_TERMS.has(term)))
-        score *= LOW_VALUE_ONLY_FACTOR;
-      const metaTopic = META_DOCS.get(doc.id);
-      if (metaTopic && !metaTopic.test(query))
-        score *= META_DOC_FACTOR;
-      return { doc, score, matched };
-    }).sort((a, b) => b.score - a.score).slice(0, limit);
-  }
-}
-const ICON_SYNONYMS = {
-  delete: ["trash"],
-  remove: ["trash", "xmark", "minus"],
-  bin: ["trash"],
-  close: ["xmark"],
-  cross: ["xmark"],
-  cancel: ["xmark"],
-  add: ["plus"],
-  plus: ["plus"],
-  new: ["plus"],
-  create: ["plus"],
-  edit: ["pencil"],
-  write: ["pencil"],
-  rename: ["pencil"],
-  search: ["magnifying", "glass"],
-  find: ["magnifying"],
-  zoom: ["magnifying"],
-  settings: ["cog", "adjustment"],
-  setting: ["cog", "adjustment"],
-  config: ["cog"],
-  preferences: ["cog", "adjustment"],
-  filter: ["funnel", "adjustment"],
-  menu: ["bars"],
-  hamburger: ["bars"],
-  user: ["user"],
-  account: ["user"],
-  profile: ["user"],
-  people: ["user"],
-  team: ["user"],
-  logout: ["arrow", "rectangle"],
-  login: ["arrow", "rectangle"],
-  signout: ["arrow", "rectangle"],
-  download: ["arrow", "down", "tray"],
-  upload: ["arrow", "up", "tray"],
-  export: ["arrow", "up", "tray"],
-  import: ["arrow", "down", "tray"],
-  back: ["arrow", "left"],
-  previous: ["chevron", "left"],
-  next: ["chevron", "right"],
-  forward: ["arrow", "right"],
-  expand: ["chevron", "down"],
-  dropdown: ["chevron", "down"],
-  success: ["check"],
-  valid: ["check"],
-  done: ["check"],
-  ok: ["check"],
-  error: ["exclamation"],
-  warning: ["exclamation", "triangle"],
-  alert: ["exclamation", "bell"],
-  info: ["information"],
-  help: ["question"],
-  notification: ["bell"],
-  email: ["envelope"],
-  mail: ["envelope"],
-  message: ["chat", "envelope"],
-  comment: ["chat"],
-  phone: ["phone", "device"],
-  call: ["phone"],
-  calendar: ["calendar"],
-  date: ["calendar"],
-  time: ["clock"],
-  clock: ["clock"],
-  favorite: ["star", "heart"],
-  like: ["heart", "thumb"],
-  love: ["heart"],
-  home: ["home"],
-  house: ["home"],
-  lock: ["lock"],
-  password: ["lock", "key"],
-  security: ["shield", "lock"],
-  visible: ["eye"],
-  show: ["eye"],
-  hide: ["eye", "slash"],
-  hidden: ["eye", "slash"],
-  copy: ["clipboard", "document", "duplicate"],
-  paste: ["clipboard"],
-  link: ["link"],
-  share: ["share"],
-  image: ["photo"],
-  picture: ["photo"],
-  camera: ["camera"],
-  video: ["video", "film"],
-  music: ["musical"],
-  file: ["document"],
-  folder: ["folder"],
-  cart: ["shopping"],
-  shop: ["shopping"],
-  payment: ["credit", "card", "banknote"],
-  money: ["banknote", "currency"],
-  refresh: ["arrow", "path"],
-  reload: ["arrow", "path"],
-  sync: ["arrow", "path"],
-  undo: ["arrow", "uturn"],
-  dark: ["moon"],
-  light: ["sun"],
-  theme: ["moon", "sun", "swatch"],
-  language: ["language", "globe"],
-  world: ["globe"],
-  location: ["map", "pin"],
-  map: ["map"],
-  chart: ["chart"],
-  stats: ["chart"],
-  print: ["printer"],
-  more: ["ellipsis"],
-  options: ["ellipsis"],
-  drag: ["bars"],
-  external: ["arrow", "top", "right", "square"],
-  github: ["github"],
-  code: ["code"]
-};
-const regionNames = new Intl.DisplayNames(["en"], { type: "region" });
-function regionName(code) {
-  try {
-    return regionNames.of(code) ?? "";
-  } catch {
-    return "";
-  }
-}
-const iconWordsCache = /* @__PURE__ */ new Map();
-function iconWords(name) {
-  const cached = iconWordsCache.get(name);
-  if (cached)
-    return cached;
-  const flag = /^MazFlag(?:Square)?([A-Z]{2})(?:[A-Z]{2})?$/.exec(name);
-  const country = flag ? regionName(flag[1]) : "";
-  const words = [...analyze(name.replace(/^Maz/, "")), ...flag ? ["flag", "country", flag[1].toLowerCase()] : [], ...analyze(country)];
-  iconWordsCache.set(name, words);
-  return words;
-}
-function searchIcons(names, query, limit = 20) {
-  const words = analyze(query.replace(/\bicons?\b/gi, ""));
-  if (words.length === 0)
-    return [];
-  const synonyms = new Map(Object.entries(ICON_SYNONYMS).map(([key, values]) => [
-    processTerm(key) ?? key,
-    values.map((value) => processTerm(value) ?? value)
-  ]));
-  return [...names].map((name) => {
-    const parts = iconWords(name);
-    const lowerName = name.toLowerCase();
-    let score = 0;
-    for (const word of words) {
-      const candidates = [word, ...synonyms.get(word) ?? []];
-      for (const [index, candidate] of candidates.entries()) {
-        const weight = index === 0 ? 1 : 0.8;
-        if (parts.includes(candidate))
-          score += 3 * weight;
-        else if (lowerName.includes(candidate))
-          score += 1.5 * weight;
-      }
-    }
-    if (score > 0 && name.startsWith("MazFlag") && !words.some((word) => ["flag", "country"].includes(word)))
-      score *= 0.3;
-    return { name, score: score - parts.length * 0.05 };
-  }).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit).map((entry) => entry.name);
-}
-
-function createContext(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const knowledge = options.knowledge ?? loadKnowledge({ ...options, cwd });
-  return {
-    knowledge,
-    search: new DocSearch(knowledge),
-    cwd
-  };
-}
-
-const COLOR_UTILITIES = "bg|text|border(?:-[trblxyse])?|ring(?:-offset)?|outline|fill|stroke|divide|from|via|to|decoration|placeholder|accent|caret|shadow|inset-shadow|inset-ring|text-shadow";
-const PALETTE = "slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose";
-const PALETTE_CLASS = new RegExp(`^(?:[\\w-]+:)*!?(${COLOR_UTILITIES})-(${PALETTE})-(\\d{2,3})(?:/\\d+)?!?$`);
-const BLACK_WHITE_CLASS = new RegExp(`^(?:[\\w-]+:)*!?(${COLOR_UTILITIES})-(white|black)(?:/\\d+)?!?$`);
-const ARBITRARY_COLOR_CLASS = /^(?:[\w-]+:)*!?[\w-]+-\[(?:#[\da-f]{3,8}|(?:rgba?|hsla?|oklch|oklab|lab|lch|color)\([^\]]*\))\]/i;
-const TAILWIND_V3_CLASS = /^(?:[\w-]+:)*!?(?:(?:bg|text|border|divide|ring|placeholder)-opacity-\d+|flex-(?:shrink|grow)(?:-\d+)?|overflow-ellipsis|decoration-(?:slice|clone))$/;
-const HUE_TO_THEME = {
-  slate: "surface / foreground / muted / divider",
-  gray: "surface / foreground / muted / divider",
-  zinc: "surface / foreground / muted / divider",
-  neutral: "surface / foreground / muted / divider",
-  stone: "surface / foreground / muted / divider",
-  red: "destructive",
-  rose: "destructive",
-  orange: "warning",
-  amber: "warning",
-  yellow: "warning",
-  green: "success",
-  emerald: "success",
-  lime: "success",
-  teal: "success / info",
-  cyan: "info",
-  sky: "info",
-  blue: "primary / info",
-  indigo: "primary",
-  violet: "secondary / accent",
-  purple: "secondary / accent",
-  fuchsia: "accent",
-  pink: "accent"
-};
-function neutralSuggestion(utility) {
-  if (utility === "text")
-    return "`text-foreground` (body text) or `text-muted` (secondary text)";
-  if (utility.startsWith("border") || utility === "divide")
-    return `\`${utility}-divider\``;
-  if (utility === "bg")
-    return "`bg-surface`, `bg-surface-{50..950}` or `bg-container`";
-  return `\`${utility}-foreground\`, \`${utility}-muted\` or \`${utility}-divider\``;
-}
-function themeSuggestion(utility, hue, step) {
-  const neutral = ["slate", "gray", "zinc", "neutral", "stone"].includes(hue);
-  if (neutral)
-    return neutralSuggestion(utility);
-  const colors = HUE_TO_THEME[hue].split(" / ");
-  const scale = step === "500" ? "" : `-${step}`;
-  return colors.map((color) => `\`${utility}-${color}${scale}\``).join(" or ");
-}
-const THEME_BACKGROUND = /^(?:[\w-]+:)*!?bg-(primary|secondary|accent|info|success|warning|destructive|contrast)(?:-\d{2,3})?(?:\/\d+)?!?$/;
-const FIXED_BACKGROUND = /^(?:[\w-]+:)*!?(?:bg-(?:overlay|black|white|transparent|linear|radial|conic|gradient|none)|bg-\[|bg-\(|from-|via-|to-)/;
-function backgroundOf(classList) {
-  for (const token of classList.split(/\s+/)) {
-    const theme = THEME_BACKGROUND.exec(token);
-    if (theme)
-      return { kind: "theme", color: theme[1] };
-    if (FIXED_BACKGROUND.test(token))
-      return { kind: "fixed" };
-  }
-  return void 0;
-}
-function reportBlackWhite(token, utility, color, background, position, context) {
-  if (background?.kind === "fixed" && utility !== "bg")
-    return;
-  if (background?.color && color === "white" && utility !== "bg") {
-    context.report({
-      rule: "theme-colors",
-      severity: "warning",
-      message: `\`${token}\` on \`bg-${background.color}\`: the theme gives the readable color of each background.`,
-      suggestion: `Use \`${utility}-${background.color}-foreground\`.`
-    }, position);
-    return;
-  }
-  context.report({
-    rule: "theme-colors",
-    severity: "warning",
-    message: `\`${token}\` is a fixed color that does not follow the theme nor dark mode.`,
-    suggestion: color === "white" ? `Use \`${utility}-surface\` (backgrounds) or the \`-foreground\` of the color behind (\`text-primary-foreground\`). Over media (image, video) or a fixed dark background, keep it with \`<!-- maz-ui-review-ignore theme-colors -- over the video -->\` above the element.` : `Use \`${utility}-foreground\` (text) or \`${utility}-contrast\`.`
-  }, position);
-}
-function checkClassList(value, offset, context, inherited) {
-  const background = backgroundOf(value) ?? inherited;
-  for (const match of value.matchAll(/\S+/g)) {
-    const token = match[0];
-    const position = offset + (match.index ?? 0);
-    if (/^(?:[\w-]+:)*maz:/.test(token) || token.startsWith("maz:")) {
-      context.report({
-        rule: "internal-prefix",
-        severity: "error",
-        message: `\`${token}\` uses the \`maz:\` prefix, which is internal to the maz-ui library and its docs: it does not exist in your project.`,
-        suggestion: `Use \`${token.replace(/maz:/g, "")}\`.`
-      }, position);
-      continue;
-    }
-    const palette = PALETTE_CLASS.exec(token);
-    if (palette) {
-      const [, utility, hue, step] = palette;
-      context.report({
-        rule: "theme-colors",
-        severity: "warning",
-        message: `\`${token}\` uses the default Tailwind palette: it ignores the maz-ui theme (presets, dark mode).`,
-        suggestion: `Use a theme color: ${themeSuggestion(utility, hue, step)}. See \`get_theme_tokens({ topics: ["colors"] })\`.`
-      }, position);
-      continue;
-    }
-    const blackWhite = BLACK_WHITE_CLASS.exec(token);
-    if (blackWhite) {
-      reportBlackWhite(token, blackWhite[1], blackWhite[2], background, position, context);
-      continue;
-    }
-    if (ARBITRARY_COLOR_CLASS.test(token)) {
-      context.report({
-        rule: "hardcoded-color",
-        severity: "warning",
-        message: `\`${token}\` hard-codes a color.`,
-        suggestion: "Use a theme color class (`bg-primary`, `text-muted`...) or `var(--maz-*)`. For a brand color missing from the theme, define it once in your Tailwind `@theme` or in the preset."
-      }, position);
-      continue;
-    }
-    if (TAILWIND_V3_CLASS.test(token)) {
-      context.report({
-        rule: "tailwind-v3",
-        severity: "warning",
-        message: `\`${token}\` is a Tailwind v3 utility removed in Tailwind v4.`,
-        suggestion: token.includes("opacity") ? "Use the opacity modifier: `bg-primary/50`." : "Use `shrink-0`, `grow`, `text-ellipsis` or `box-decoration-slice`."
-      }, position);
-    }
-  }
-}
-function checkClassStrings(code, offset, context) {
-  for (const match of code.matchAll(/(['"`])((?:(?!\1)[^\\\n]|\\.)*)\1/g)) {
-    const content = match[2];
-    if (/(?:^|\s)(?:[\w-]+:)*(?:maz:|(?:bg|text|border|ring|fill|stroke|from|to|via|outline|divide)-)/.test(content))
-      checkClassList(content, offset + (match.index ?? 0) + 1, context);
-  }
-}
-
-const UTILS_NAMES = {
-  debounce: "`debounce` from `@maz-ui/utils/helpers/debounce`",
-  throttle: "`throttle` from `@maz-ui/utils/helpers/throttle`",
-  isEqual: "`isEqual` from `@maz-ui/utils/helpers/isEqual`",
-  capitalize: "`capitalize` from `@maz-ui/utils/helpers/capitalize`",
-  upperFirst: "`upperFirst` from `@maz-ui/utils/helpers/upperFirst`",
-  camelCase: "`camelCase` from `@maz-ui/utils/helpers/camelCase`",
-  kebabCase: "`kebabCase` from `@maz-ui/utils/helpers/kebabCase`",
-  snakeCase: "`snakeCase` from `@maz-ui/utils/helpers/snakeCase`",
-  startCase: "`pascalCase` or `normalizeString` from `@maz-ui/utils`",
-  delay: "`sleep` from `@maz-ui/utils/helpers/sleep`"
-};
-const THIRD_PARTY_RULES = [
-  { packages: ["lodash", "lodash-es", "lodash/", "lodash-es/", "underscore", "radash", "es-toolkit"], names: UTILS_NAMES, severity: "warning", rule: "prefer-utils" },
-  { packages: ["lodash.debounce", "just-debounce-it", "debounce", "p-debounce"], replacement: UTILS_NAMES.debounce, severity: "warning", rule: "prefer-utils" },
-  { packages: ["lodash.throttle", "just-throttle", "throttle-debounce"], replacement: "`debounce` / `throttle` from `@maz-ui/utils`", severity: "warning", rule: "prefer-utils" },
-  { packages: ["js-cookie", "universal-cookie", "vue-cookies"], replacement: "`getCookie`, `setCookie`, `deleteCookie` from `@maz-ui/utils/helpers/cookie`", severity: "warning", rule: "prefer-utils" },
-  {
-    packages: ["@vueuse/core"],
-    names: {
-      useWindowSize: "`useWindowSize` from `maz-ui/composables/useWindowSize`",
-      useBreakpoints: "`useBreakpoints` from `maz-ui/composables/useBreakpoints`",
-      onClickOutside: "the `vClickOutside` directive (`maz-ui/directives/vClickOutside`)",
-      useIdle: "`useIdleTimeout` from `maz-ui/composables/useIdleTimeout`",
-      useSwipe: "`useSwipe` from `maz-ui/composables/useSwipe`",
-      useDocumentVisibility: "`useUserVisibility` from `maz-ui/composables/useUserVisibility`",
-      useDropZone: "MazDropzone or `useDropzone` (`maz-ui/composables/useDropzone`)",
-      useDark: "`useTheme` from `@maz-ui/themes` (`isDark`, `toggleDarkMode`)",
-      useColorMode: "`useTheme` from `@maz-ui/themes` (`colorMode`, `setColorMode`)",
-      usePreferredDark: "`useTheme` from `@maz-ui/themes`",
-      useDebounceFn: "`debounce` from `@maz-ui/utils/helpers/debounce`",
-      useThrottleFn: "`throttle` from `@maz-ui/utils/helpers/throttle`"
-    },
-    severity: "info",
-    rule: "prefer-ecosystem"
-  },
-  { packages: ["vue-toastification", "vue-sonner", "vue3-toastify", "notivue", "@kyvg/vue3-notification", "vue-toast-notification"], replacement: "`useToast()` (maz-ui toast plugin)", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["@heroicons/vue", "lucide-vue-next", "@lucide/vue", "@iconify/vue", "@phosphor-icons/vue", "@tabler/icons-vue", "vue-feather-icons", "@fortawesome/", "unplugin-icons", "~icons/", "virtual:icons/", "@mdi/js", "oh-vue-icons"], replacement: "@maz-ui/icons (`find_icons`)", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["floating-vue", "v-tooltip", "tippy.js", "vue-tippy"], replacement: "the `vTooltip` directive or MazPopover", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["@floating-ui/vue", "@floating-ui/dom", "@popperjs/core"], replacement: "MazPopover (floating panel with positioning, triggers and focus management) or `vTooltip`", severity: "info", rule: "prefer-ecosystem" },
-  { packages: ["vue-chartjs", "vue-chart-3", "apexcharts", "vue3-apexcharts", "echarts", "vue-echarts"], replacement: "MazChart (chart.js based)", severity: "info", rule: "prefer-ecosystem" },
-  { packages: ["@vuepic/vue-datepicker", "vue-datepicker-next", "v-calendar", "vue-flatpickr-component", "flatpickr"], replacement: "MazDatePicker", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue-tel-input", "vue-phone-number-input", "vue-country-code"], replacement: "MazInputPhoneNumber / MazSelectCountry", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue-multiselect", "vue-select", "@vueform/multiselect", "vue3-select-component"], replacement: "MazSelect (search, multiple, groups, custom options)", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue-final-modal", "@kouts/vue-modal", "vue-js-modal"], replacement: "MazDialog, MazDialogConfirm or MazBottomSheet", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue3-dropzone", "vue-dropzone", "dropzone", "vue-upload-component", "filepond", "vue-filepond"], replacement: "MazDropzone", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue3-otp-input", "vue-otp-input"], replacement: "MazInputCode", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue3-carousel", "vue-agile", "swiper/vue"], replacement: "MazCarousel", severity: "info", rule: "prefer-ecosystem" },
-  { packages: ["vue-skeletor", "vue-content-loader", "vue-loading-skeleton"], replacement: "MazSkeleton", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue-loading-overlay", "vue-spinner", "vue-spinners", "epic-spinners"], replacement: "MazSpinner, MazFullscreenLoader or `useWait`", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vue-easy-lightbox", "vue-image-zoomer", "medium-zoom", "viewerjs", "v-viewer"], replacement: "the `vZoomImg` / `vFullscreenImg` directives or MazGallery", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["aos"], replacement: "the maz-ui AOS plugin (`useAos`)", severity: "warning", rule: "prefer-ecosystem" },
-  { packages: ["vee-validate", "@vuelidate/core", "vuelidate"], replacement: "`useFormValidator` / `useFormField` with your Standard Schema library (Zod, Valibot, ArkType)", severity: "info", rule: "prefer-ecosystem" }
-];
-const IMPORT_REGEX = /import\s+(type\s+)?(?:([\w$]+)\s*(?:,\s*)?)?(?:\{([^}]*)\}|\*\s+as\s+[\w$]+)?\s*from\s*['"]([^'"]+)['"]|import\s*['"]([^'"]+)['"]/g;
-function parseImports(code) {
-  return [...code.matchAll(IMPORT_REGEX)].map((match) => {
-    const [, typeKeyword, defaultName, named, specifier, sideEffect] = match;
-    const names = (named ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry && !entry.startsWith("type ")).map((entry) => entry.split(/\s+as\s+/)[0].trim());
-    return {
-      specifier: specifier ?? sideEffect,
-      names: defaultName ? [defaultName, ...names] : names,
-      typeOnly: !!typeKeyword,
-      offset: match.index ?? 0
-    };
-  });
-}
-function matchesPackage(specifier, packages) {
-  return packages.some((name) => name.endsWith("/") ? specifier.startsWith(name) : specifier === name || specifier.startsWith(`${name}/`));
-}
-function checkEntryPoint(entry, offset, context) {
-  if (/^(?:maz-ui|@maz-ui\/[\w-]+)\/(?:src|dist)(?:\/|$)/.test(entry.specifier)) {
-    context.report({
-      rule: "internal-import",
-      severity: "error",
-      message: `\`${entry.specifier}\` imports internal files of the package.`,
-      suggestion: "Use the public entries: `maz-ui/components/MazBtn`, `maz-ui/composables/useToast`, `@maz-ui/utils/helpers/debounce`..."
-    }, offset);
-    return true;
-  }
-  if (entry.specifier === "maz-ui" && !entry.typeOnly && entry.names.length > 0) {
-    context.report({
-      rule: "root-import",
-      severity: "error",
-      message: "`maz-ui` (root entry) only exports types: runtime imports from it are undefined.",
-      suggestion: "Import from the entries: `maz-ui/components/MazBtn`, `maz-ui/composables/useToast`, `maz-ui/directives/vTooltip`, `maz-ui/plugins/maz-ui`. Use `import type` for types."
-    }, offset);
-    return true;
-  }
-  return false;
-}
-function checkComponentImport(entry, offset, context) {
-  const name = /^maz-ui\/components\/(Maz\w+)$/.exec(entry.specifier)?.[1];
-  if (!name || context.knowledge.componentsByName.has(name))
-    return;
-  const near = closest(name, context.knowledge.componentsByName.keys(), { max: 3, limit: 2 });
-  context.report({
-    rule: "unknown-component",
-    severity: "error",
-    message: `\`${name}\` is not a maz-ui component.`,
-    suggestion: near.length > 0 ? `Did you mean ${near.map((candidate) => `\`${candidate}\``).join(" or ")}?` : "Find the right one with `search_docs`."
-  }, offset);
-}
-function checkIconImport(entry, offset, context) {
-  if (entry.specifier !== "@maz-ui/icons" && !entry.specifier.startsWith("@maz-ui/icons/"))
-    return;
-  const fromPath = /^@maz-ui\/icons\/(?:static|lazy|raw)\/(\w+)$/.exec(entry.specifier)?.[1];
-  const icons = [...entry.names, ...fromPath ? [fromPath] : []].map((name) => name.replace(/^Lazy(?=Maz)/, "")).filter((name) => name.startsWith("Maz") && !context.knowledge.iconNames.has(name));
-  for (const icon of new Set(icons)) {
-    const near = closest(icon, context.knowledge.iconNames, { max: 3, limit: 3 });
-    context.report({
-      rule: "unknown-icon",
-      severity: "error",
-      message: `\`${icon}\` does not exist in @maz-ui/icons.`,
-      suggestion: near.length > 0 ? `Did you mean ${near.map((name) => `\`${name}\``).join(" or ")}? Search with \`find_icons\`.` : 'Search with `find_icons({ query: "..." })`.'
-    }, offset);
-  }
-}
-function isNuxtAutoImported(entry) {
-  if (/^maz-ui\/(?:components(?:\/Maz\w+)?|composables(?:\/use\w+)?)$/.test(entry.specifier))
-    return true;
-  return ["@maz-ui/themes", "@maz-ui/translations"].includes(entry.specifier) && entry.names.some((name) => ["useTheme", "useTranslations"].includes(name));
-}
-function checkEcosystemImport(entry, offset, context) {
-  if (checkEntryPoint(entry, offset, context))
-    return;
-  checkComponentImport(entry, offset, context);
-  checkIconImport(entry, offset, context);
-  if (context.framework === "nuxt" && !entry.typeOnly && isNuxtAutoImported(entry)) {
-    context.report({
-      rule: "nuxt-auto-import",
-      severity: "info",
-      message: `\`${entry.specifier}\` is auto-imported by @maz-ui/nuxt.`,
-      suggestion: "Remove the import (keep `import type` imports)."
-    }, offset);
-  }
-}
-function checkThirdPartyImport(entry, offset, context) {
-  if (entry.typeOnly)
-    return;
-  for (const rule of THIRD_PARTY_RULES) {
-    if (!matchesPackage(entry.specifier, rule.packages))
-      continue;
-    if (rule.names) {
-      const lodashPath = /^lodash(?:-es)?\/(\w+)$/.exec(entry.specifier)?.[1];
-      const flagged = [...entry.names, ...lodashPath ? [lodashPath] : []].filter((name) => rule.names?.[name]);
-      for (const name of flagged) {
-        context.report({
-          rule: rule.rule,
-          severity: rule.severity,
-          message: `\`${name}\` from \`${entry.specifier}\` duplicates the maz-ui ecosystem.`,
-          suggestion: `Use ${rule.names[name]}.`
-        }, offset);
-      }
-      continue;
-    }
-    context.report({
-      rule: rule.rule,
-      severity: rule.severity,
-      message: `\`${entry.specifier}\` duplicates a feature of the maz-ui ecosystem.`,
-      suggestion: `Use ${rule.replacement} instead of adding a dependency.`
-    }, offset);
-    return;
-  }
-}
-const DARK_MODE_PATTERNS = [
-  { regex: /classList\.(?:add|remove|toggle)\(\s*['"`]dark['"`]/g, message: "Toggles the `dark` class by hand." },
-  { regex: /localStorage\.(?:get|set)Item\(\s*['"`](?:theme|color-?mode|dark(?:-?mode)?)['"`]/gi, message: "Stores the color mode by hand." },
-  { regex: /matchMedia\(\s*['"`]\(prefers-color-scheme/g, message: "Reads `prefers-color-scheme` by hand." }
-];
-function reviewScript(code, offset, context) {
-  for (const entry of parseImports(code)) {
-    const position = offset + entry.offset;
-    if (/^(?:maz-ui|@maz-ui\/)/.test(entry.specifier))
-      checkEcosystemImport(entry, position, context);
-    else
-      checkThirdPartyImport(entry, position, context);
-  }
-  for (const { regex, message } of DARK_MODE_PATTERNS) {
-    for (const match of code.matchAll(regex)) {
-      context.report({
-        rule: "manual-dark-mode",
-        severity: "warning",
-        message,
-        suggestion: '`useTheme()` from `@maz-ui/themes` handles it: `toggleDarkMode()`, `setColorMode("dark" | "light" | "auto")`, `isDark`. The color mode is persisted and applied without flash.'
-      }, offset + (match.index ?? 0));
-    }
-  }
-  checkClassStrings(code.replaceAll(/^\s*import\s[^\n]*$/gm, (line) => " ".repeat(line.length)), offset, context);
-}
-function mazUiName(imported, source) {
-  if (!/^(?:maz-ui|@maz-ui\/icons)(?:\/|$)/.test(source))
-    return void 0;
-  return imported ?? source.split("/").at(-1);
-}
-function localComponents(scripts) {
-  const components = /* @__PURE__ */ new Map();
-  for (const [, clause, source] of scripts.matchAll(/import\s+(?!type\s)([^'";]*?)\s+from\s+["']([^"']+)["']/g)) {
-    const named = /\{([^}]*)\}/.exec(clause)?.[1] ?? "";
-    const defaultName = /^\s*([A-Z]\w*)/.exec(clause.replace(/\{[^}]*\}/, ""))?.[1];
-    if (defaultName)
-      components.set(defaultName, mazUiName(void 0, source));
-    for (const specifier of named.split(",")) {
-      const [imported, local = imported] = specifier.replace(/^\s*type\s+/, "").split(/\s+as\s+/).map((part) => part.trim());
-      if (/^[A-Z]/.test(local ?? ""))
-        components.set(local, mazUiName(imported, source));
-    }
-  }
-  return components;
-}
-
-const COLOR_LITERAL = /#[\da-f]{3,8}\b|\b(?:rgba?|hsla?|oklch|oklab|lab|lch)\(/i;
-const COLOR_PROPERTIES = /^(?:color|background(?:-color)?|border(?:-[a-z]+)*-color|border(?:-(?:top|right|bottom|left|inline|block)(?:-(?:start|end))?)?|outline(?:-color)?|fill|stroke|box-shadow|text-shadow|caret-color|accent-color|text-decoration-color|column-rule-color)$/;
-function blankComments$1(css) {
-  return css.replaceAll(/\/\*[\s\S]*?\*\//g, (match) => match.replaceAll(/[^\n]/g, " "));
-}
-const BLACK_OR_WHITE = /^#(?:f{3}|f{6}|f{8}|0{3}|0{6}|0{8})$/i;
-function keyframesRanges(css) {
-  const ranges = [];
-  for (const match of css.matchAll(/@keyframes[^{]*\{/g)) {
-    const start = match.index ?? 0;
-    let depth = 0;
-    for (let index = start + match[0].length - 1; index < css.length; index++) {
-      if (css[index] === "{") {
-        depth++;
-      } else if (css[index] === "}" && --depth === 0) {
-        ranges.push([start, index]);
-        break;
-      }
-    }
-  }
-  return ranges;
-}
-function checkStyleDeclarations(css, offset, context) {
-  const keyframes = keyframesRanges(css);
-  for (const match of css.matchAll(/(^|[;{\s])([a-z-]+)\s*:\s*([^;{}]+)/g)) {
-    const [, prefix, property, value] = match;
-    if (property.startsWith("--") || !COLOR_PROPERTIES.test(property) || /var\(--/.test(value))
-      continue;
-    const color = COLOR_LITERAL.exec(value);
-    if (!color)
-      continue;
-    const index = match.index ?? 0;
-    const inKeyframes = keyframes.some(([start, end]) => index > start && index < end);
-    const blackOrWhite = BLACK_OR_WHITE.test(color[0]);
-    context.report({
-      rule: "hardcoded-color",
-      severity: inKeyframes || blackOrWhite ? "info" : "warning",
-      message: `\`${property}\` uses a hard-coded color (\`${color[0].replace("(", "")}\`): it ignores the theme and dark mode.`,
-      suggestion: `Use a theme variable: \`var(--maz-primary)\`, \`var(--maz-surface)\`, \`var(--maz-foreground)\`, \`var(--maz-muted)\`, \`var(--maz-divider)\`... (\`color-mix(in oklab, var(--maz-primary) 20%, transparent)\` for tints).${blackOrWhite ? " Keep it if the element is over media (image, video) or a fixed dark background." : ""}`
-    }, offset + index + prefix.length);
-  }
-}
-function reviewStyle(source, offset, context, { sfc = false } = {}) {
-  const css = blankComments$1(source);
-  const applies = [...css.matchAll(/@apply\s+([^;]+);/g)];
-  for (const apply of applies) {
-    checkClassList(apply[1], offset + (apply.index ?? 0) + apply[0].indexOf(apply[1]), context);
-  }
-  if (sfc && applies.length > 0 && !/@reference\s/.test(css)) {
-    context.report({
-      rule: "missing-reference",
-      severity: "error",
-      message: "`@apply` in a Vue SFC `<style>` block needs a `@reference` to your Tailwind entry with Tailwind v4.",
-      suggestion: 'Start the block with `@reference "<relative path to your Tailwind entry css>";`.'
-    }, offset + (applies[0].index ?? 0));
-  }
-  const withoutThemeBlocks = css.replaceAll(/@theme[^{]*\{[^}]*\}/g, (match) => match.replaceAll(/[^\n]/g, " "));
-  checkStyleDeclarations(withoutThemeBlocks, offset, context);
-}
-
-const GLOBAL_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "id",
-  "class",
-  "style",
-  "title",
-  "role",
-  "tabindex",
-  "hidden",
-  "lang",
-  "dir",
-  "draggable",
-  "translate",
-  "inert",
-  "popover",
-  "slot",
-  "part",
-  "is",
-  "key",
-  "ref",
-  "name",
-  "type",
-  "value",
-  "placeholder",
-  "autocomplete",
-  "autofocus",
-  "autocapitalize",
-  "autocorrect",
-  "spellcheck",
-  "inputmode",
-  "enterkeyhint",
-  "maxlength",
-  "minlength",
-  "max",
-  "min",
-  "step",
-  "pattern",
-  "readonly",
-  "required",
-  "disabled",
-  "multiple",
-  "accept",
-  "capture",
-  "form",
-  "list",
-  "size",
-  "rows",
-  "cols",
-  "wrap",
-  "checked",
-  "selected",
-  "href",
-  "target",
-  "rel",
-  "download",
-  "src",
-  "srcset",
-  "sizes",
-  "alt",
-  "width",
-  "height",
-  "loading",
-  "decoding",
-  "for",
-  "label",
-  "contenteditable",
-  "accesskey",
-  "nonce"
-]);
-const NATIVE_EVENTS = /* @__PURE__ */ new Set([
-  "click",
-  "dblclick",
-  "contextmenu",
-  "mousedown",
-  "mouseup",
-  "mouseenter",
-  "mouseleave",
-  "mouseover",
-  "mouseout",
-  "mousemove",
-  "pointerdown",
-  "pointerup",
-  "pointerenter",
-  "pointerleave",
-  "pointermove",
-  "pointercancel",
-  "touchstart",
-  "touchend",
-  "touchmove",
-  "touchcancel",
-  "keydown",
-  "keyup",
-  "keypress",
-  "focus",
-  "blur",
-  "focusin",
-  "focusout",
-  "input",
-  "change",
-  "submit",
-  "reset",
-  "invalid",
-  "scroll",
-  "wheel",
-  "resize",
-  "drag",
-  "dragstart",
-  "dragend",
-  "dragenter",
-  "dragleave",
-  "dragover",
-  "drop",
-  "copy",
-  "cut",
-  "paste",
-  "load",
-  "error",
-  "animationstart",
-  "animationend",
-  "transitionend",
-  "select"
-]);
-function isPassthroughAttribute(name) {
-  return GLOBAL_ATTRIBUTES.has(name) || name.startsWith("data-") || name.startsWith("aria-") || name.startsWith("on");
-}
-function nativeReplacement(tag, type) {
-  switch (tag) {
-    case "button":
-      return { component: "MazBtn", severity: "warning" };
-    case "select":
-      return { component: "MazSelect", severity: "warning" };
-    case "textarea":
-      return { component: "MazTextarea", severity: "warning" };
-    case "dialog":
-      return { component: "MazDialog", severity: "warning" };
-    case "table":
-      return { component: "MazTable", severity: "info" };
-    case "progress":
-      return { component: "MazLoadingBar or MazCircularProgressBar", severity: "info" };
-    case "details":
-      return { component: "MazAccordion or MazExpandAnimation", severity: "info" };
-    case "input":
-      return inputReplacement(type);
-    default:
-      return void 0;
-  }
-}
-function inputReplacement(type = "text") {
-  switch (type) {
-    case "hidden":
-    case "submit":
-    case "reset":
-    case "image":
-    case "color":
-      return void 0;
-    case "checkbox":
-      return { component: "MazCheckbox (or MazSwitch for a toggle)", severity: "warning" };
-    case "radio":
-      return { component: "MazRadio or MazRadioButtons", severity: "warning" };
-    case "range":
-      return { component: "MazSlider", severity: "warning" };
-    case "file":
-      return { component: "MazDropzone", severity: "info" };
-    case "tel":
-      return { component: "MazInputPhoneNumber", severity: "warning" };
-    case "number":
-      return { component: "MazInputNumber (or MazInputPrice for amounts)", severity: "warning" };
-    case "date":
-    case "datetime-local":
-    case "month":
-    case "week":
-    case "time":
-      return { component: "MazDatePicker", severity: "warning" };
-    default:
-      return { component: "MazInput", severity: "warning" };
-  }
-}
-
-function toCamel(value) {
-  return value.replaceAll(/-([a-z\d])/g, (_, char) => char.toUpperCase());
-}
-function toPascal(tag) {
-  const camel = toCamel(tag);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-function isElement(node) {
-  return node.type === NodeTypes.ELEMENT;
-}
-function staticAttribute(element, name) {
-  return element.props.find((prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === name);
-}
-function directiveArg(directive) {
-  return directive.arg?.type === NodeTypes.SIMPLE_EXPRESSION && directive.arg.isStatic ? directive.arg.content : void 0;
-}
-function directiveExpression(directive) {
-  return directive.exp?.type === NodeTypes.SIMPLE_EXPRESSION ? { content: directive.exp.content, offset: directive.exp.loc.start.offset } : void 0;
-}
-function valueOffset(attribute, source) {
-  const start = attribute.value?.loc.start.offset ?? attribute.loc.start.offset;
-  return /["']/.test(source[start] ?? "") ? start + 1 : start;
-}
-function findProp(component, name) {
-  const camel = toCamel(name);
-  return component.props.find((prop) => prop.name === camel);
-}
-function mazTagName(tag) {
-  const pascal = toPascal(tag).replace(/^Lazy(?=Maz)/, "");
-  return /^Maz[A-Z\d]/.test(pascal) ? pascal : void 0;
-}
-function checkPropValue(prop, value, offset, component, context) {
-  if (prop.type === "boolean" && (value === "false" || value === "true")) {
-    context.report({
-      rule: "boolean-prop-string",
-      severity: value === "false" ? "error" : "info",
-      message: `\`${toKebab(prop.name)}="${value}"\` on ${component.name} passes the string "${value}"${value === "false" ? ", which is truthy" : ""}.`,
-      suggestion: value === "false" ? `Remove the attribute or bind it: \`:${toKebab(prop.name)}="false"\`.` : `Write \`${toKebab(prop.name)}\` alone.`
-    }, offset);
-    return;
-  }
-  if (prop.strictValues && prop.values && !prop.values.includes(value)) {
-    const near = closest(value, prop.values, { max: 2, limit: 1 });
-    context.report({
-      rule: "invalid-prop-value",
-      severity: "error",
-      message: `"${value}" is not a valid \`${toKebab(prop.name)}\` for ${component.name}.`,
-      suggestion: `Accepted values: ${prop.values.map((entry) => `"${entry}"`).join(", ")}.${near[0] ? ` Did you mean "${near[0]}"?` : ""}`
-    }, offset);
-  }
-}
-const PROP_SYNONYMS = {
-  items: ["options"],
-  choices: ["options"],
-  list: ["options"],
-  data: ["options", "rows"],
-  columns: ["headers"],
-  value: ["modelValue"],
-  checked: ["modelValue"],
-  selected: ["modelValue"],
-  open: ["modelValue"],
-  isOpen: ["modelValue"],
-  show: ["modelValue"],
-  visible: ["modelValue"],
-  active: ["modelValue"],
-  text: ["label", "title", "content"],
-  helperText: ["hint"],
-  helper: ["hint"],
-  message: ["hint"],
-  errorMessage: ["hint", "error"],
-  variant: ["color", "fill", "outlined"],
-  image: ["src"],
-  leftIcon: ["startIcon"],
-  rightIcon: ["endIcon"],
-  prependIcon: ["startIcon"],
-  appendIcon: ["endIcon"]
-};
-function nameWords(name) {
-  return toKebab(name).split("-").filter(Boolean);
-}
-function propSuggestions(name, component, { containing = true } = {}) {
-  const camel = toCamel(name);
-  const props = component.props.map((prop) => prop.name);
-  const synonyms = (PROP_SYNONYMS[camel] ?? []).filter((prop) => props.includes(prop));
-  const words = nameWords(camel.replace(/^(?:is|has)(?=[A-Z])/, ""));
-  const withWords = containing ? props.filter((prop) => words.every((word) => nameWords(prop).includes(word))).sort((a, b) => a.length - b.length) : [];
-  const near = closest(camel, props, { max: camel.length <= 3 ? 1 : 2, limit: 2 });
-  return [.../* @__PURE__ */ new Set([...synonyms, ...withWords, ...near])].slice(0, 3);
-}
-function reportUnknownProp(name, offset, component, context) {
-  const passthrough = isPassthroughAttribute(name);
-  const near = propSuggestions(name, component, { containing: !passthrough });
-  if (passthrough && near.length === 0)
-    return;
-  const names = near.map((entry) => entry === "modelValue" ? "`v-model`" : `\`${toKebab(entry)}\``).join(" or ");
-  context.report({
-    rule: "unknown-prop",
-    severity: "warning",
-    message: passthrough ? `\`${name}\` is not a prop of ${component.name}: it is only forwarded as an HTML attribute (the component may not use it).` : `${component.name} has no prop \`${name}\`: it will only be forwarded as an HTML attribute.`,
-    suggestion: near.length > 0 ? `Did you mean ${names}? Check \`get_component_api({ names: ["${component.name}"] })\`.` : `Check the real API with \`get_component_api({ names: ["${component.name}"] })\`.`
-  }, offset);
-}
-function checkModel(directive, component, context) {
-  const arg = directiveArg(directive) ?? "modelValue";
-  const prop = findProp(component, arg);
-  if (!prop) {
-    const models = component.props.filter((entry) => entry.model).map((entry) => entry.name === "modelValue" ? "v-model" : `v-model:${toKebab(entry.name)}`);
-    context.report({
-      rule: "unknown-model",
-      severity: "error",
-      message: `${component.name} has no \`${arg === "modelValue" ? "v-model" : `v-model:${arg}`}\`.`,
-      suggestion: models.length > 0 ? `Available: ${models.map((entry) => `\`${entry}\``).join(", ")}.` : `${component.name} has no v-model.`
-    }, directive.loc.start.offset);
-  }
-}
-function checkEvent(directive, component, context) {
-  const name = directiveArg(directive);
-  if (!name)
-    return;
-  const kebab = toKebab(name);
-  const events = component.events.map((event) => event.name);
-  if (events.includes(kebab) || events.includes(name) || NATIVE_EVENTS.has(kebab.split(".")[0]))
-    return;
-  const updateMatch = /^update:(.+)$/.exec(kebab);
-  if (updateMatch) {
-    if (!findProp(component, updateMatch[1])) {
-      context.report({
-        rule: "unknown-event",
-        severity: "error",
-        message: `${component.name} never emits \`${name}\`: it has no \`${toCamel(updateMatch[1])}\` prop.`,
-        suggestion: `Events: ${events.map((event) => `\`@${event}\``).join(", ") || "none"}.`
-      }, directive.loc.start.offset);
-    }
-    return;
-  }
-  const near = closest(kebab, [...events, ...NATIVE_EVENTS], { max: 2, limit: 1 });
-  context.report({
-    rule: "unknown-event",
-    severity: near.length > 0 ? "error" : "warning",
-    message: `${component.name} does not emit \`${name}\` and it is not a DOM event.`,
-    suggestion: near.length > 0 ? `Did you mean \`@${near[0]}\`?` : `Events: ${events.map((event) => `\`@${event}\``).join(", ") || "none (DOM events like @click still work)"}.`
-  }, directive.loc.start.offset);
-}
-function isStaticSlot(prop) {
-  return prop.type === NodeTypes.DIRECTIVE && prop.name === "slot" && (!prop.arg || prop.arg.type !== NodeTypes.SIMPLE_EXPRESSION || prop.arg.isStatic);
-}
-function usedSlots(element) {
-  const templates = element.children.filter((child) => isElement(child) && child.tag === "template");
-  return [element, ...templates].flatMap((node) => node.props.filter(isStaticSlot)).map((prop) => ({ name: directiveArg(prop) ?? "default", offset: prop.loc.start.offset }));
-}
-function slotMatches(slot, name) {
-  if (!slot.includes("{"))
-    return slot === name;
-  const [prefix, suffix] = slot.split(/\{[^}]*\}/);
-  return name.length > prefix.length + suffix.length && name.startsWith(prefix) && name.endsWith(suffix);
-}
-function checkSlots(element, component, context) {
-  const slots = component.slots.map((slot) => slot.name);
-  for (const { name, offset } of usedSlots(element)) {
-    if (slots.some((slot) => slotMatches(slot, name)) || name === "default" && slots.length === 0)
-      continue;
-    const near = closest(name, slots, { max: 3, limit: 2 });
-    context.report({
-      rule: "unknown-slot",
-      severity: "error",
-      message: `${component.name} has no \`#${name}\` slot: its content will not be rendered.`,
-      suggestion: near.length > 0 ? `Did you mean ${near.map((entry) => `\`#${entry}\``).join(" or ")}?` : `Slots: ${slots.map((slot) => `\`#${slot}\``).join(", ") || "none"}.`
-    }, offset);
-  }
-}
-const STYLE_BINDINGS = /* @__PURE__ */ new Set(["class", "style", "key"]);
-function checkStaticAttribute(attribute, component, source, context) {
-  if (STYLE_BINDINGS.has(attribute.name))
-    return;
-  const definition = findProp(component, attribute.name);
-  if (!definition)
-    reportUnknownProp(attribute.name, attribute.loc.start.offset, component, context);
-  else if (attribute.value)
-    checkPropValue(definition, attribute.value.content, valueOffset(attribute, source), component, context);
-}
-function checkBoundProp(directive, component, context) {
-  const name = directiveArg(directive);
-  if (!name || STYLE_BINDINGS.has(name))
-    return;
-  const definition = findProp(component, name);
-  if (!definition) {
-    reportUnknownProp(name, directive.loc.start.offset, component, context);
-    return;
-  }
-  const expression = directiveExpression(directive);
-  const literal = expression?.content.trim();
-  if (expression && literal && /^'[^']*'$|^"[^"]*"$/.test(literal) && definition.type !== "boolean")
-    checkPropValue(definition, literal.slice(1, -1), expression.offset, component, context);
-}
-function checkMazComponent(element, component, source, context) {
-  for (const prop of element.props) {
-    if (prop.type === NodeTypes.ATTRIBUTE)
-      checkStaticAttribute(prop, component, source, context);
-    else if (prop.name === "bind")
-      checkBoundProp(prop, component, context);
-    else if (prop.name === "model")
-      checkModel(prop, component, context);
-    else if (prop.name === "on")
-      checkEvent(prop, component, context);
-  }
-  checkSlots(element, component, context);
-}
-const SVG_SHAPES = /* @__PURE__ */ new Set(["path", "circle", "rect", "polyline", "polygon", "line", "ellipse"]);
-const ICON_MAX_VIEWBOX = 32;
-function descendantsOf(element) {
-  return element.children.filter(isElement).flatMap((child) => [child, ...descendantsOf(child)]);
-}
-function isAnimated(element) {
-  const classes = staticAttribute(element, "class")?.value?.content ?? "";
-  return element.tag.startsWith("animate") || /\banimate-|\[animation/.test(classes) || element.props.some((prop) => prop.name.startsWith("stroke-dash"));
-}
-function isIconLikeSvg(svg) {
-  const descendants = descendantsOf(svg);
-  if (!descendants.some((child) => SVG_SHAPES.has(child.tag)))
-    return false;
-  const viewBox = staticAttribute(svg, "viewBox")?.value?.content.trim().split(/[\s,]+/).map(Number);
-  if (viewBox?.length === 4 && (viewBox[2] > ICON_MAX_VIEWBOX || viewBox[3] > ICON_MAX_VIEWBOX))
-    return false;
-  return ![svg, ...descendants].some((node) => isAnimated(node) || node !== svg && node.props.some((prop) => prop.type === NodeTypes.DIRECTIVE));
-}
-const LAYOUT_TAGS = /* @__PURE__ */ new Set(["div", "p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li", "dl", "img", "picture", "video", "canvas", "section", "article", "header", "footer", "figure", "table"]);
-const NEUTRAL_COMPONENTS = /* @__PURE__ */ new Set(["Transition", "TransitionGroup", "KeepAlive", "Teleport", "Suspense", "ClientOnly", "NuxtLink", "RouterLink"]);
-function contentOf(element) {
-  return element.children.filter((child) => child.type !== NodeTypes.COMMENT && !(child.type === NodeTypes.TEXT && child.content.trim() === ""));
-}
-function isIconOrDecoration(element, context) {
-  const pascal = toPascal(element.tag).replace(/^Lazy/, "");
-  return element.tag === "svg" || element.tag === "component" || context.knowledge.iconNames.has(pascal) || pascal.endsWith("Icon") || ["i", "span"].includes(element.tag) && contentOf(element).length === 0;
-}
-function isComponentTag(element) {
-  return /^[A-Z]/.test(element.tag) || element.tag.includes("-");
-}
-function isCompositeButton(button, context) {
-  const descendants = descendantsOf(button);
-  if (descendants.some((node) => LAYOUT_TAGS.has(node.tag)))
-    return true;
-  if (descendants.some((node) => isComponentTag(node) && !NEUTRAL_COMPONENTS.has(toPascal(node.tag)) && !isIconOrDecoration(node, context)))
-    return true;
-  return hasStackedLabels(button, context);
-}
-function hasStackedLabels(element, context) {
-  const content = contentOf(element);
-  const labels = content.filter((child) => isElement(child) && !isIconOrDecoration(child, context));
-  const isSentence = content.some((child) => !isElement(child));
-  return labels.length >= 2 && !isSentence || labels.some((label) => hasStackedLabels(label, context));
-}
-function checkNativeElement(element, context) {
-  if (element.tag === "svg" && isIconLikeSvg(element)) {
-    context.report({
-      rule: "inline-svg",
-      severity: "warning",
-      message: "Inline SVG icon.",
-      suggestion: 'Use an icon from @maz-ui/icons: `find_icons({ query: "..." })`.'
-    }, element.loc.start.offset);
-    return;
-  }
-  if (element.tag === "button" && (contentOf(element).length === 0 || isCompositeButton(element, context)))
-    return;
-  const replacement = nativeReplacement(element.tag, staticAttribute(element, "type")?.value?.content);
-  if (replacement) {
-    context.report({
-      rule: "prefer-maz-component",
-      severity: replacement.severity,
-      message: `Native \`<${element.tag}>\`${element.tag === "input" ? ` (type "${staticAttribute(element, "type")?.value?.content ?? "text"}")` : ""}.`,
-      suggestion: `Use ${replacement.component}: themed, accessible and consistent with the rest of the UI. Add \`<!-- maz-ui-review-ignore -->\` above it if the native element is intended.`
-    }, element.loc.start.offset);
-  }
-}
-function checkClassBindings(element, source, context, inherited) {
-  for (const prop of element.props) {
-    if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "class" && prop.value) {
-      checkClassList(prop.value.content, valueOffset(prop, source), context, inherited);
-    } else if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "style" && prop.value) {
-      checkStyleDeclarations(prop.value.content, valueOffset(prop, source), context);
-    } else if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && directiveArg(prop) === "class") {
-      const expression = directiveExpression(prop);
-      if (expression)
-        checkClassStrings(expression.content, expression.offset, context);
-    }
-  }
-}
-function checkMazTag(element, mazName, source, context) {
-  const component = context.knowledge.componentsByName.get(mazName);
-  if (component) {
-    checkMazComponent(element, component, source, context);
-    return;
-  }
-  if (context.knowledge.iconNames.has(mazName))
-    return;
-  const near = closest(mazName, [...context.knowledge.componentsByName.keys(), ...context.knowledge.iconNames], { max: 3, limit: 3 });
-  context.report({
-    rule: "unknown-component",
-    severity: "error",
-    message: `\`<${element.tag}>\` is neither a maz-ui component nor a @maz-ui/icons icon.`,
-    suggestion: near.length > 0 ? `Did you mean ${near.map((entry) => `\`${entry}\``).join(" or ")}?` : "Use `search_docs` or `find_icons` to find the right name."
-  }, element.loc.start.offset);
-}
-function walk(node, source, context, background) {
-  for (const child of node.children) {
-    if (!isElement(child))
-      continue;
-    const pascal = /[A-Z-]/.test(child.tag) ? toPascal(child.tag) : void 0;
-    const mazName = pascal && context.localComponents?.has(pascal) ? mazTagName(context.localComponents.get(pascal) ?? "") : mazTagName(child.tag);
-    if (mazName)
-      checkMazTag(child, mazName, source, context);
-    else
-      checkNativeElement(child, context);
-    checkClassBindings(child, source, context, background);
-    walk(child, source, context, backgroundOf(staticAttribute(child, "class")?.value?.content ?? "") ?? background);
-  }
-}
-function reviewTemplate(root, source, context) {
-  walk(root, source, context);
-}
-
-const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
-
-function detectKind(code, filename) {
-  const extension = filename?.split(".").pop()?.toLowerCase();
-  if (extension === "vue")
-    return "vue";
-  if (["ts", "tsx", "js", "jsx", "mjs", "mts", "cjs", "cts"].includes(extension ?? ""))
-    return "script";
-  if (["css", "scss", "pcss", "postcss", "sass", "less"].includes(extension ?? ""))
-    return "style";
-  if (extension === "html")
-    return "template";
-  if (/<template[\s>]|<script[\s>]/.test(code))
-    return "vue";
-  if (/^\s*</.test(code))
-    return "template";
-  if (/^\s*(?:@import|@theme|[.#:@\w-][^{;]*\{)/.test(code) && !/(?:^|[^@\w])(?:import|const|function|export)\s/.test(code))
-    return "style";
-  return "script";
-}
-function lineStarts(code) {
-  const starts = [0];
-  for (let index = 0; index < code.length; index++) {
-    if (code[index] === "\n")
-      starts.push(index + 1);
-  }
-  return starts;
-}
-function locate(starts, offset) {
-  let low = 0;
-  let high = starts.length - 1;
-  while (low < high) {
-    const middle = Math.ceil((low + high) / 2);
-    if (starts[middle] <= offset)
-      low = middle;
-    else
-      high = middle - 1;
-  }
-  return { line: low + 1, column: offset - starts[low] + 1 };
-}
-function ignoredRules(lines) {
-  const byLine = /* @__PURE__ */ new Map();
-  let file;
-  const parseRules = (rest) => {
-    const [directive] = rest.replace(/-->|\*\/|\*\}|\}/g, "").split(/\s--\s/);
-    const rules = directive.split(/[\s,]+/).filter((rule) => /^[a-z][a-z\d-]+$/.test(rule));
-    return rules.length > 0 ? new Set(rules) : "all";
-  };
-  for (const [index, line] of lines.entries()) {
-    const fileMatch = /maz-ui-review-ignore-file\b(.*)/.exec(line);
-    if (fileMatch) {
-      file = parseRules(fileMatch[1]);
-      continue;
-    }
-    const match = /maz-ui-review-ignore\b(.*)/.exec(line);
-    if (!match)
-      continue;
-    const isAlone = /^\s*(?:<!--|\/\/|\/\*|\{\/\*)\s*maz-ui-review-ignore/.test(line);
-    byLine.set(isAlone ? index + 2 : index + 1, parseRules(match[1]));
-  }
-  return { file, byLine };
-}
-function isIgnored(rule, scope) {
-  return scope === "all" || scope instanceof Set && scope.has(rule);
-}
-function blocksOf(root) {
-  return root.children.filter((child) => child.type === NodeTypes.ELEMENT);
-}
-function blockContent(block) {
-  const first = block.children[0];
-  const last = block.children.at(-1);
-  if (!first || !last)
-    return { content: "", offset: block.loc.end.offset };
-  const start = first.loc.start.offset;
-  const end = last.loc.end.offset;
-  return { content: block.loc.source.slice(start - block.loc.start.offset, end - block.loc.start.offset), offset: start };
-}
-function reviewCode(code, options) {
-  const starts = lineStarts(code);
-  const findings = [];
-  const seen = /* @__PURE__ */ new Set();
-  const context = {
-    ...options,
-    report: (finding, offset) => {
-      const position = locate(starts, offset);
-      const key = `${finding.rule}:${position.line}:${position.column}:${finding.message}`;
-      if (seen.has(key))
-        return;
-      seen.add(key);
-      findings.push({ ...finding, ...position });
-    }
-  };
-  const kind = detectKind(code, options.filename);
-  if (kind === "script") {
-    reviewScript(code, 0, context);
-  } else if (kind === "style") {
-    reviewStyle(code, 0, context);
-  } else if (kind === "template") {
-    reviewTemplate(parse(code), code, context);
-  } else {
-    const root = parse(code, { parseMode: "sfc" });
-    const blocks = blocksOf(root);
-    context.localComponents = localComponents(blocks.filter((block) => block.tag === "script").map((block) => blockContent(block).content).join("\n"));
-    for (const block of blocks) {
-      if (block.tag === "template") {
-        reviewTemplate(block, code, context);
-      } else if (block.tag === "script") {
-        const { content, offset } = blockContent(block);
-        reviewScript(content, offset, context);
-      } else if (block.tag === "style") {
-        const { content, offset } = blockContent(block);
-        reviewStyle(content, offset, context, { sfc: true });
-      }
-    }
-  }
-  const { file, byLine } = ignoredRules(code.split("\n"));
-  return findings.filter((finding) => !isIgnored(finding.rule, file) && !isIgnored(finding.rule, byLine.get(finding.line))).sort((a, b) => a.line - b.line || a.column - b.column || SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
-}
-function countBySeverity(findings) {
-  return {
-    error: findings.filter((finding) => finding.severity === "error").length,
-    warning: findings.filter((finding) => finding.severity === "warning").length,
-    info: findings.filter((finding) => finding.severity === "info").length
-  };
-}
-function filterBySeverity(findings, minimum) {
-  return findings.filter((finding) => SEVERITY_ORDER[finding.severity] <= SEVERITY_ORDER[minimum]);
-}
-function formatFindings(findings, label) {
-  const counts = countBySeverity(findings);
-  if (findings.length === 0)
-    return `${label}: no issue found.`;
-  const summary = ["error", "warning", "info"].filter((severity) => counts[severity] > 0).map((severity) => `${counts[severity]} ${severity}${counts[severity] > 1 ? "s" : ""}`).join(", ");
-  return [
-    `${label}: ${summary}`,
-    ...findings.map((finding) => `- L${finding.line}:${finding.column} ${finding.severity} [${finding.rule}] ${finding.message}${finding.suggestion ? `
-  -> ${finding.suggestion}` : ""}`)
-  ].join("\n");
-}
-
-const REVIEWABLE_EXTENSIONS = ["vue", "ts", "tsx", "js", "jsx", "mjs", "mts", "css", "scss", "pcss", "postcss"];
-const MAX_REVIEWED_FILES = 200;
-function detectFramework(fromDirectory) {
-  let directory = fromDirectory;
-  for (; ; ) {
-    if (["nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"].some((file) => existsSync(join(directory, file))))
-      return "nuxt";
-    if (existsSync(join(directory, "package.json")))
-      return "vue";
-    const parent = dirname(directory);
-    if (parent === directory)
-      return "vue";
-    directory = parent;
-  }
-}
-async function expandPaths(patterns, cwd) {
-  const files = /* @__PURE__ */ new Set();
-  const globs = [];
-  for (const pattern of patterns) {
-    const absolute = isAbsolute(pattern) ? pattern : resolve(cwd, pattern);
-    if (existsSync(absolute) && statSync(absolute).isFile())
-      files.add(absolute);
-    else if (existsSync(absolute) && statSync(absolute).isDirectory())
-      globs.push(`${relative(cwd, absolute) || "."}/**/*.{${REVIEWABLE_EXTENSIONS.join(",")}}`);
-    else
-      globs.push(pattern);
-  }
-  if (globs.length > 0) {
-    const matches = await glob(globs, { cwd, absolute: true, ignore: ["**/node_modules/**", "**/dist/**", "**/.nuxt/**", "**/.output/**", "**/coverage/**"] });
-    for (const match of matches) files.add(match);
-  }
-  return [...files].filter((file) => REVIEWABLE_EXTENSIONS.includes(file.split(".").pop() ?? "")).sort();
-}
-function displayPath(cwd, file) {
-  const path = relative(cwd, file);
-  return path && !path.startsWith("..") && !isAbsolute(path) ? path : file;
-}
-async function reviewFiles(patterns, { knowledge, cwd, framework, minSeverity = "info" }) {
-  const files = await expandPaths(patterns, cwd);
-  return {
-    truncated: files.length > MAX_REVIEWED_FILES,
-    reviews: files.slice(0, MAX_REVIEWED_FILES).map((file) => ({
-      file: displayPath(cwd, file),
-      findings: filterBySeverity(
-        reviewCode(readFileSync(file, "utf8"), { knowledge, filename: file, framework: framework ?? detectFramework(dirname(file)) }),
-        minSeverity
-      )
-    }))
-  };
-}
-
-const FENCE = /^\s*(?:`{3,}|~{3,})/;
-function stripFrontmatter(markdown) {
-  return markdown.replace(/^---\n[\s\S]*?\n---\n+/, "");
-}
-function linksToDocIds(markdown, doc) {
-  const base = doc.file.split("/").slice(0, -1);
-  return markdown.replaceAll(/\]\((\.{1,2}\/[^)\s]+?\.md)(#[^)\s]*)?\)/g, (_, path, anchor = "") => {
-    const parts = [...base];
-    for (const segment of path.split("/")) {
-      if (segment === "..")
-        parts.pop();
-      else if (segment !== ".")
-        parts.push(segment);
-    }
-    const id = parts.join("/").replace(/\.md$/, "").replace(/\/index$/, "");
-    return `](${id}${anchor})`;
-  });
-}
-function listSections(markdown) {
-  const lines = markdown.split("\n");
-  const sections = [];
-  let inFence = false;
-  for (const [index, line] of lines.entries()) {
-    if (FENCE.test(line)) {
-      inFence = !inFence;
-      continue;
-    }
-    const match = !inFence && /^(#{2,4})\s+(\S.*)$/.exec(line);
-    if (match)
-      sections.push({ title: match[2].trim(), level: match[1].length, start: index, end: lines.length });
-  }
-  for (const [index, section] of sections.entries()) {
-    const next = sections.slice(index + 1).find((candidate) => candidate.level <= section.level);
-    section.end = next ? next.start : lines.length;
-  }
-  return sections;
-}
-function normalize(value) {
-  return value.toLowerCase().replaceAll(/[^a-z\d]+/g, " ").trim();
-}
-function findSection(markdown, title) {
-  const sections = listSections(markdown);
-  const wanted = normalize(title);
-  return sections.find((section) => normalize(section.title) === wanted) ?? sections.find((section) => normalize(section.title).startsWith(wanted)) ?? sections.find((section) => normalize(section.title).includes(wanted));
-}
-function sectionContent(markdown, section) {
-  return markdown.split("\n").slice(section.start, section.end).join("\n").trim();
-}
-function outline(markdown) {
-  return listSections(markdown).filter((section) => section.level <= 3).map((section) => `${section.level === 3 ? "  " : ""}- ${section.title}`).join("\n");
-}
-function truncateText(value, max) {
-  return value.length <= max ? value : `${value.slice(0, max - 3).trimEnd()}...`;
-}
-
-class ToolInputError extends Error {
-}
-function defineTool(definition) {
-  return definition;
-}
-
-const CATEGORY_TITLES = {
-  guide: "Guides",
-  component: "Components (maz-ui)",
-  composable: "Composables (maz-ui)",
-  directive: "Directives (maz-ui)",
-  plugin: "Plugins (maz-ui)",
-  ecosystem: "Ecosystem packages",
-  util: "Helpers (@maz-ui/utils)",
-  node: "Node utilities (@maz-ui/node)",
-  reference: "References"
-};
-function describeSource(context) {
-  const { source, version } = context.knowledge;
-  if (source.kind === "project")
-    return `Docs of maz-ui ${version}, read from the project (node_modules/maz-ui/docs).`;
-  if (source.kind === "custom")
-    return `Docs of maz-ui ${version}, read from ${source.directory}.`;
-  if (source.projectVersion && source.projectVersion !== version)
-    return `The project uses maz-ui ${source.projectVersion}, which does not ship its docs: these are the docs of maz-ui ${version} (bundled with @maz-ui/mcp). Double check APIs that may differ.`;
-  return `Docs of maz-ui ${version} (bundled with @maz-ui/mcp).`;
-}
-function listDocs(context, { category }) {
-  const categories = category ? [category] : docCategories;
-  const sections = categories.map((current) => {
-    const docs = context.knowledge.docs.filter((doc) => doc.category === current);
-    if (docs.length === 0)
-      return "";
-    const lines = docs.map((doc) => `- ${doc.title} \`${doc.id}\`: ${truncateText(doc.description, 120)}`);
-    return `## ${CATEGORY_TITLES[current]} (${docs.length})
-
-${lines.join("\n")}`;
-  }).filter(Boolean);
-  return [
-    `# maz-ui ecosystem catalog`,
-    "",
-    describeSource(context),
-    "",
-    ...sections.flatMap((section) => [section, ""]),
-    "Read a page with `get_doc({ id })`, a component API with `get_component_api({ names })`."
-  ].join("\n");
-}
-const listDocsTool = defineTool({
-  name: "list_docs",
-  title: "maz-ui catalog",
-  description: "Catalog of everything maz-ui and its ecosystem provide (installed version), one line per item with its id: components, composables, directives, plugins, @maz-ui/utils helpers, ecosystem packages (themes, translations, icons, nuxt), guides and references. Use it to get an overview; prefer `search_docs` to find something for a given need.",
-  inputSchema: {
-    category: z.enum(docCategories).optional().describe("Only list this category")
-  },
-  run: listDocs
-});
-
-function buildInstructions(context) {
-  return `maz-ui ${context.knowledge.version}: docs, component APIs, icons, Tailwind theme tokens and code review for the maz-ui ecosystem (Vue 3 and Nuxt UI library: components, composables, directives, plugins, @maz-ui/themes, @maz-ui/icons, @maz-ui/utils, @maz-ui/translations, @maz-ui/nuxt). ${describeSource(context)}
-
-Use these tools whenever you write, refactor or review Vue/Nuxt UI code, styles or helpers in a project that uses maz-ui. Most UI elements, helpers and icons already exist: reuse them instead of re-implementing them.
-
-Workflow:
-1. search_docs("<the need in plain words>") BEFORE creating a component, composable, helper, icon or style ("confirm before delete", "phone input", "debounce search", "dark mode toggle").
-2. get_component_api(["MazBtn", ...]) BEFORE writing a template with Maz* components: use only documented props, values, events and slots.
-3. find_icons("<meaning>") for icons: never inline SVG nor another icon library.
-4. get_theme_tokens() BEFORE styling: it reads the project theme (preset, @theme tokens, variants, utilities) and lists the maz-ui classes. Theme colors only (bg-surface, text-foreground, text-muted, border-divider, bg-primary text-primary-foreground, bg-container...), radius, shadow-elevation, breakpoints mob-*/tab-*/lap-*.
-5. review_code({ paths: [...] }) on the files you changed, then fix every error and warning.
-Other tools: get_doc (pages and guides: guide/tailwind, ecosystem/themes, ecosystem/translations, ecosystem/nuxt, guide/vue, guide/migration-v5...), list_docs (catalog), get_setup_guide (install in Vue or Nuxt).
-
-Rules:
-- Maz* components instead of native or hand-made elements (MazBtn, MazInput, MazSelect, MazDialog, MazDialogConfirm, MazCard, MazTable, MazAvatar, MazBadge, MazAlert, MazSkeleton, MazDatePicker, MazDropzone...). useToast for notifications, useDialog for confirmations.
-- @maz-ui/utils and maz-ui composables instead of lodash, VueUse or custom code (debounce, throttle, formatCurrency, formatDate, isEqual, cookies, useBreakpoints, useTimer...).
-- Tailwind: never the default palette (bg-blue-500, text-gray-600, bg-white) nor hard-coded colors; theme colors already handle dark mode (no dark: color overrides); never the internal \`maz:\` prefix. Custom CSS uses var(--maz-*).
-- Theme through a @maz-ui/themes preset and useTheme() (toggleDarkMode, setColorMode), never by hand.
-- Deep imports (maz-ui/components/MazBtn, maz-ui/composables/useToast, @maz-ui/utils/helpers/debounce, @maz-ui/icons/static/MazTrash); the maz-ui root only exports types. With @maz-ui/nuxt, components and composables are auto-imported.`;
-}
-
-function userMessage(text) {
-  return { messages: [{ role: "user", content: { type: "text", text } }] };
-}
-function registerPrompts(server) {
-  server.registerPrompt("build", {
-    title: "Build with maz-ui",
-    description: "Implement a feature, page or component with the maz-ui ecosystem instead of re-implementing it",
-    argsSchema: {
-      task: z.string().describe("What to build")
-    }
-  }, ({ task }) => userMessage(`Implement the following with the maz-ui ecosystem: ${task}
-
-1. Split the task into UI elements, behaviors, helpers, icons and styles.
-2. For each one, call \`search_docs\` with the need in plain words and pick what maz-ui provides (components, composables, directives, plugins, @maz-ui/utils helpers).
-3. Call \`get_component_api\` (batch) for every Maz* component you will use, \`find_icons\` for icons and \`get_theme_tokens\` for the Tailwind classes. Read \`get_doc\` examples when the usage is not obvious.
-4. Write the code: Maz* components, theme colors only, deep imports (or Nuxt auto-imports), no new dependency for something maz-ui covers.
-5. Run \`review_code\` on the files you changed and fix every error and warning.`));
-  server.registerPrompt("audit", {
-    title: "Audit maz-ui usage",
-    description: "Find and fix what re-implements maz-ui in existing code (native elements, other libraries, default Tailwind palette, wrong APIs)",
-    argsSchema: {
-      paths: z.string().describe('Files, folders or globs to audit, comma separated (e.g. "src/components, src/pages")')
-    }
-  }, ({ paths }) => userMessage(`Audit how these files use the maz-ui ecosystem: ${paths}
-
-1. Run \`review_code\` with these paths.
-2. For each finding, check the replacement with \`search_docs\`, \`get_component_api\`, \`find_icons\` or \`get_theme_tokens\`, then fix it without changing the behavior.
-3. Also look for hand-made code that maz-ui already provides (formatting, debounce, toasts, dialogs, loaders, skeletons, breakpoints, dark mode) and replace it.
-4. Run \`review_code\` again until no error or warning remains, and summarize the changes.`));
-  server.registerPrompt("setup", {
-    title: "Set up maz-ui",
-    description: "Install and configure maz-ui, its theme, translations and Tailwind integration in this project",
-    argsSchema: {
-      framework: z.enum(["vue", "nuxt"]).describe("Framework of the project")
-    }
-  }, ({ framework }) => userMessage(`Set up maz-ui in this ${framework} project.
-
-1. Read the project (package.json, ${framework === "nuxt" ? "nuxt.config" : "main.ts"}, CSS entry, Tailwind setup) to know what is already there.
-2. Call \`get_setup_guide({ framework: "${framework}" })\` and apply it: dependencies, ${framework === "nuxt" ? "the @maz-ui/nuxt module options" : "the MazUi plugin with a theme preset and translations"}, CSS imports and Tailwind theme tokens.
-3. Run \`npx @maz-ui/mcp init\` so every AI agent of the project gets the maz-ui rules and this MCP server.
-4. Verify that the app builds and that a MazBtn renders with the theme.`));
-}
-
-function findIcons(context, { query, limit = 24 }) {
-  const { iconNames } = context.knowledge;
-  const exact = [...iconNames].find((name) => name.toLowerCase() === query.trim().toLowerCase());
-  const names = exact ? [exact, ...searchIcons(iconNames, query, limit).filter((name) => name !== exact)].slice(0, limit) : searchIcons(iconNames, query, limit);
-  if (names.length === 0) {
-    const near = closest(query.startsWith("Maz") ? query : `Maz${query}`, iconNames, { max: 4, limit: 8 });
-    return [
-      `No icon matches "${query}" in @maz-ui/icons (${iconNames.size} icons).`,
-      near.length > 0 ? `Close names: ${near.join(", ")}.` : "",
-      'Try another English word (icons follow the heroicons naming: trash, x-mark, magnifying-glass, cog, bars-3, chevron-down...). Full list: `get_doc({ id: "reference/icons" })`.'
-    ].filter(Boolean).join("\n");
-  }
-  const [first] = names;
-  return [
-    `# @maz-ui/icons matching "${query}"`,
-    "",
-    names.map((name) => `- \`${name}\``).join("\n"),
-    "",
-    "## Import",
-    "",
-    "```ts",
-    `import { ${first} } from '@maz-ui/icons/static/${first}' // tree-shakable component`,
-    `import { ${first} } from '@maz-ui/icons/lazy/${first}' // lazy-loaded async component`,
-    `import { ${first} } from '@maz-ui/icons/raw/${first}' // raw SVG string`,
-    "```",
-    "",
-    `Render \`<${first} class="size-5 text-primary" />\` (size and color from CSS, the SVG uses \`currentColor\`), or pass it to an icon prop: \`<MazBtn :start-icon="${first}">\`. Never inline SVG markup nor add another icon library.`
-  ].join("\n");
-}
-const findIconsTool = defineTool({
-  name: "find_icons",
-  title: "Find @maz-ui/icons",
-  description: 'Find icons in @maz-ui/icons (860+ heroicons-based icons, brand logos and country flags) from what they represent ("delete", "close", "settings", "user", "france flag", "github") and get their import. Use it instead of inline SVG or another icon library.',
-  inputSchema: {
-    query: z.string().min(1).describe("What the icon represents, in English, or an icon name"),
-    limit: z.number().int().min(1).max(60).optional().describe("Maximum number of icons (default 24)")
-  },
-  run: findIcons
-});
-
-function getComponentApi(context, { names }) {
-  const blocks = [];
-  const unknown = [];
-  for (const name of [...new Set(names)]) {
-    const component = resolveComponent(context.knowledge, name);
-    if (!component) {
-      unknown.push(name);
-      continue;
-    }
-    const doc = context.knowledge.docsById.get(component.docId);
-    const markdown = doc ? linksToDocIds(stripFrontmatter(context.knowledge.readDoc(doc.id)), doc) : "";
-    const section = findSection(markdown, `${component.name} API`);
-    const api = section ? sectionContent(markdown, section) : `## ${component.name} API
-
-\`${component.import}\``;
-    const parent = component.parent ? `
-
-Building block of \`${component.parent}\`: see \`get_doc({ id: "${context.knowledge.componentsByName.get(component.parent)?.docId}" })\` for complete examples.` : "";
-    blocks.push(`${api}${parent}
-
-Examples: \`get_doc({ id: "${component.docId}" })\``);
-  }
-  if (blocks.length === 0) {
-    const suggestions = unknown.flatMap((name) => closest(name, context.knowledge.componentsByName.keys(), { max: 4 }));
-    throw new ToolInputError([
-      `Unknown maz-ui component${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}.`,
-      suggestions.length > 0 ? `Did you mean: ${[...new Set(suggestions)].join(", ")}?` : "",
-      'Use `search_docs` to find a component from a need, or `list_docs({ category: "component" })`.'
-    ].filter(Boolean).join("\n"));
-  }
-  if (unknown.length > 0) {
-    const suggestions = unknown.flatMap((name) => closest(name, context.knowledge.componentsByName.keys(), { max: 4 }));
-    blocks.push(`Unknown: ${unknown.join(", ")}.${suggestions.length > 0 ? ` Did you mean ${[...new Set(suggestions)].join(", ")}?` : ""}`);
-  }
-  return [
-    `Props are listed in kebab-case (use \`:prop\` for dynamic values). Values marked "non exhaustive" accept other values. Never use undocumented props, events or slots.`,
-    ...blocks
-  ].join("\n\n---\n\n");
-}
-const getComponentApiTool = defineTool({
-  name: "get_component_api",
-  title: "maz-ui component API",
-  description: "Exact API of one or more maz-ui components (installed version): import, props with types, defaults and accepted values, v-model, events with payload, slots with bindings, exposed methods. Call it before writing a template with a Maz* component; batch up to 10 components in one call.",
-  inputSchema: {
-    names: z.array(z.string().min(1)).min(1).max(10).describe('Component names: ["MazBtn", "MazDialog"] (kebab-case and short names like "btn" work)')
-  },
-  run: getComponentApi
-});
-
-const WEAK_MATCH_SCORE = 150;
-function nextCall(doc) {
-  if (doc.category === "component")
-    return `get_component_api({ names: ["${doc.title}"] }) for the API, get_doc({ id: "${doc.id}" }) for examples`;
-  if (doc.id === "reference/tailwind-tokens")
-    return "get_theme_tokens()";
-  if (doc.id === "reference/icons")
-    return 'find_icons({ query: "..." })';
-  return `get_doc({ id: "${doc.id}" })`;
-}
-function formatDocLine(doc, index) {
-  const prefix = index === void 0 ? "-" : `${index + 1}.`;
-  const lines = [
-    `${prefix} **${doc.title}** (${doc.category}, \`${doc.id}\`): ${truncateText(doc.description, 220)}`
-  ];
-  if (doc.imports[0])
-    lines.push(`   \`${doc.imports[0]}\``);
-  lines.push(`   Next: ${nextCall(doc)}`);
-  return lines.join("\n");
-}
-function searchDocs(context, { query, category, limit = 8 }) {
-  const hits = context.search.search(query, { category, limit });
-  const header = `# maz-ui ${context.knowledge.version} results for "${query}"${category ? ` (category: ${category})` : ""}`;
-  if (hits.length === 0) {
-    return [
-      header,
-      "",
-      'No result. Try other words describing the need (e.g. "modal" or "dialog", "notification" or "toast"), remove the category filter, or browse with `list_docs`.',
-      "If maz-ui does not provide it, build it with maz-ui components and the theme tokens (`get_theme_tokens`)."
-    ].join("\n");
-  }
-  const lines = [header, "", ...hits.map((hit, index) => formatDocLine(hit.doc, index))];
-  if (hits[0].score < WEAK_MATCH_SCORE) {
-    lines.push("", "These results are weak matches: maz-ui probably has no dedicated feature for this need. Compose it from maz-ui components (MazCard, MazBtn, MazIcon...) and theme tokens (`get_theme_tokens`) rather than adding another library.");
-  }
-  if (/\bicons?\b/i.test(query)) {
-    const icons = searchIcons(context.knowledge.iconNames, query, 8);
-    if (icons.length > 0)
-      lines.push("", `Icons: ${icons.join(", ")}. Use \`find_icons\` for imports.`);
-  }
-  return lines.join("\n");
-}
-const searchDocsTool = defineTool({
-  name: "search_docs",
-  title: "Search maz-ui",
-  description: 'Find what maz-ui and its ecosystem already provide for a need, BEFORE writing a component, composable, helper or style. Describe the need in plain words ("user avatar with initials", "confirm before delete", "phone number input", "debounce search", "dark mode toggle", "tailwind breakpoints"); names (MazBtn, useToast) and aliases from other libraries (modal, snackbar, combobox) work too. Returns ranked components, composables, directives, plugins, helpers (@maz-ui/utils), guides and references with their import and the next tool to call.',
-  inputSchema: {
-    query: z.string().min(1).describe("The need or the name to look for, in English"),
-    category: z.enum(docCategories).optional().describe("Restrict to one category"),
-    limit: z.number().int().min(1).max(20).optional().describe("Number of results (default 8)")
-  },
-  run: searchDocs
-});
-
-const MAX_FULL_DOC_CHARS = 24e3;
-const PREVIEW_CHARS = 6e3;
-function notFoundMessage(context, query) {
-  const suggestions = context.search.search(query, { limit: 5 });
-  return [
-    `No maz-ui doc matches "${query}".`,
-    ...suggestions.length > 0 ? ["", "Closest docs:", ...suggestions.map((hit) => formatDocLine(hit.doc))] : [],
-    "",
-    'Pass an id from `search_docs` or `list_docs` (e.g. "components/maz-btn", "composables/use-toast", "guide/tailwind").'
-  ].join("\n");
-}
-function related(context, doc) {
-  const docs = doc.related.map((id) => context.knowledge.docsById.get(id)).filter((entry) => !!entry);
-  return docs.length > 0 ? `
-
-Related: ${docs.map((entry) => `\`${entry.id}\` (${entry.title})`).join(", ")}` : "";
-}
-function getDoc(context, { id, sections, full = false }) {
-  const doc = resolveDoc(context.knowledge, id);
-  if (!doc)
-    throw new ToolInputError(notFoundMessage(context, id));
-  const markdown = linksToDocIds(stripFrontmatter(context.knowledge.readDoc(doc.id)), doc);
-  if (sections?.length) {
-    const found = sections.map((title) => ({ title, section: findSection(markdown, title) }));
-    const missing = found.filter((entry) => !entry.section).map((entry) => entry.title);
-    if (missing.length === found.length) {
-      throw new ToolInputError(`No section "${missing.join('", "')}" in \`${doc.id}\`. Available sections:
-${outline(markdown)}`);
-    }
-    return [
-      `# ${doc.title} (\`${doc.id}\`)`,
-      ...found.filter((entry) => entry.section).map((entry) => sectionContent(markdown, entry.section)),
-      ...missing.length > 0 ? [`Sections not found: ${missing.join(", ")}.`] : []
-    ].join("\n\n");
-  }
-  if (full || markdown.length <= MAX_FULL_DOC_CHARS)
-    return `${markdown.trim()}${related(context, doc)}`;
-  const firstSection = listSections(markdown)[0];
-  const intro = markdown.slice(0, Math.min(firstSection ? markdown.split("\n").slice(0, firstSection.start).join("\n").length : PREVIEW_CHARS, PREVIEW_CHARS));
-  const apiHint = doc.category === "component" ? `
-
-For the props, events and slots: \`get_component_api({ names: ${JSON.stringify(doc.symbols)} })\`.` : "";
-  return [
-    intro.trim(),
-    "",
-    `This page is long (${markdown.length} characters). Request the sections you need with \`get_doc({ id: "${doc.id}", sections: ["..."] })\`, or \`full: true\` for everything.${apiHint}`,
-    "",
-    "## Sections",
-    "",
-    outline(markdown)
-  ].join("\n") + related(context, doc);
-}
-const getDocTool = defineTool({
-  name: "get_doc",
-  title: "Read a maz-ui doc page",
-  description: 'Read a maz-ui documentation page (usage, examples, options) of the installed version: a component, composable, directive, plugin, helper, guide (tailwind, vue, getting-started, migration-v5...) or ecosystem package (themes, translations, icons, nuxt). Accepts an id ("components/maz-btn", "guide/tailwind", "ecosystem/themes") or a name (MazBtn, useToast, vTooltip, debounce). Long pages return an outline: then ask for specific sections.',
-  inputSchema: {
-    id: z.string().min(1).describe('Doc id or name: "components/maz-btn", "MazBtn", "useToast", "guide/tailwind", "ecosystem/themes"'),
-    sections: z.array(z.string()).max(10).optional().describe('Only return these sections (heading titles, e.g. ["Basic usage", "Loading"])'),
-    full: z.boolean().optional().describe("Return the whole page even when it is long")
-  },
-  run: getDoc
-});
-
-function sections(context, id, titles) {
-  const doc = context.knowledge.docsById.get(id);
-  if (!doc)
-    return [];
-  const markdown = linksToDocIds(stripFrontmatter(context.knowledge.readDoc(id)), doc);
-  return titles.map((title) => findSection(markdown, title)).filter((section) => !!section).map((section) => sectionContent(markdown, section));
-}
-function getSetupGuide(context, { framework, tailwind = true }) {
-  const parts = [`# Set up maz-ui ${context.knowledge.version} in a ${framework === "nuxt" ? "Nuxt" : "Vue"} app`];
-  if (framework === "nuxt")
-    parts.push(...sections(context, "ecosystem/nuxt", ["Installation", "Minimal Setup"]));
-  else
-    parts.push(...sections(context, "guide/vue", ["Quick Start"]));
-  if (tailwind) {
-    parts.push(
-      "## Tailwind CSS",
-      ...sections(context, "guide/tailwind", ["Setup"]),
-      `Then style with the theme tokens only (\`get_theme_tokens\`).${framework === "nuxt" ? " With Tailwind, set `mazUi.css.injectCss: false` and import `maz-ui/style.css` first in your Tailwind entry to control the CSS order." : ""}`
-    );
-  }
-  parts.push(
-    "## AI agents",
-    "Run `npx @maz-ui/mcp init` in the project: it registers this MCP server and writes the maz-ui rules for your agents (Claude Code, Cursor, Copilot, Codex...) without touching your own instructions.",
-    `Full guides: \`get_doc({ id: "${framework === "nuxt" ? "ecosystem/nuxt" : "guide/vue"}" })\`, \`get_doc({ id: "ecosystem/themes" })\` (presets, dark mode), \`get_doc({ id: "ecosystem/translations" })\`.`
-  );
-  return parts.join("\n\n");
-}
-const getSetupGuideTool = defineTool({
-  name: "get_setup_guide",
-  title: "Set up maz-ui",
-  description: "Installation and configuration steps of maz-ui for a Vue (Vite) or Nuxt app, with or without Tailwind CSS: packages to install, plugin or Nuxt module options, theme preset, translations, CSS entry and AI agent setup.",
-  inputSchema: {
-    framework: z.enum(["vue", "nuxt"]).describe("Target framework"),
-    tailwind: z.boolean().optional().describe("Include the Tailwind CSS integration (default true)")
-  },
-  run: getSetupGuide
-});
-
-function sourceOf(node, source) {
-  return source.slice(node.start ?? 0, node.end ?? 0).replaceAll(/\s+/g, " ");
-}
-function keyOf(node) {
-  if (node.type !== "ObjectProperty" || node.computed)
-    return void 0;
-  if (node.key.type === "Identifier")
-    return node.key.name;
-  return node.key.type === "StringLiteral" || node.key.type === "NumericLiteral" ? String(node.key.value) : void 0;
-}
-function unwrap(node) {
-  return node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression" ? unwrap(node.expression) : node;
-}
-function literalValue(node, source) {
-  const expression = unwrap(node);
-  switch (expression.type) {
-    case "StringLiteral":
-    case "NumericLiteral":
-    case "BooleanLiteral":
-      return expression.value;
-    case "NullLiteral":
-      return null;
-    case "TemplateLiteral":
-      return expression.expressions.length === 0 ? expression.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("") : `<expr: ${sourceOf(expression, source)}>`;
-    case "ArrayExpression":
-      return expression.elements.map((element) => element && element.type !== "SpreadElement" ? literalValue(element, source) : null);
-    case "ObjectExpression":
-      return Object.fromEntries(expression.properties.flatMap((property) => {
-        const key = keyOf(property);
-        return key && property.type === "ObjectProperty" ? [[key, literalValue(property.value, source)]] : [];
-      }));
-    default:
-      return `<expr: ${sourceOf(expression, source)}>`;
-  }
-}
-function isDefinePreset(node) {
-  return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "definePreset";
-}
-function findPresetCalls(node, found, name) {
-  if (isDefinePreset(node)) {
-    found.push({ call: node, name });
-    return;
-  }
-  const variableName = node.type === "VariableDeclarator" && node.id.type === "Identifier" ? node.id.name : name;
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments")
-      continue;
-    for (const child of Array.isArray(value) ? value : [value]) {
-      if (child && typeof child === "object" && typeof child.type === "string")
-        findPresetCalls(child, found, variableName);
-    }
-  }
-}
-function readPresets(file, source) {
-  let program;
-  try {
-    program = parse$1(source, { sourceType: "module", plugins: ["typescript"], errorRecovery: true }).program;
-  } catch {
-    return [];
-  }
-  const calls = [];
-  findPresetCalls(program, calls);
-  return calls.flatMap(({ call, name }) => {
-    const [argument] = call.arguments;
-    if (!argument || argument.type !== "ObjectExpression")
-      return [];
-    const options = literalValue(argument, source);
-    const base = options.base;
-    const overrides = options.overrides;
-    return [{
-      file,
-      exportName: name,
-      base: typeof base === "string" ? base.replace(/^<expr: (.*)>$/, "$1") : void 0,
-      overrides: overrides && typeof overrides === "object" && !Array.isArray(overrides) ? overrides : {}
-    }];
-  });
-}
-
-const BLOCK_AT_RULES = /^@(?:utility|keyframes|custom-variant)\s/;
-function blankComments(css, comments) {
-  return css.replaceAll(/\/\*([\s\S]*?)\*\//g, (match, text, index) => {
-    comments.push({ end: index + match.length, text: text.replaceAll(/\s*\n\s*\*?\s*/g, " ").trim() });
-    return match.replaceAll(/[^\n]/g, " ");
-  });
-}
-function commentBefore(css, comments, start) {
-  const comment = comments.findLast((entry) => entry.end <= start);
-  return comment && css.slice(comment.end, start).trim() === "" ? comment.text : void 0;
-}
-function parseCss(source) {
-  const comments = [];
-  const css = blankComments(source, comments);
-  const result = { declarations: [], statements: [], blocks: [] };
-  const stack = [];
-  let start = 0;
-  let parens = 0;
-  let quote;
-  const flush = (end) => {
-    const raw = css.slice(start, end);
-    const statement = raw.trim();
-    const position = start + raw.indexOf(statement);
-    if (statement.startsWith("@")) {
-      result.statements.push(statement.replaceAll(/\s+/g, " "));
-      return;
-    }
-    const declaration = /^(--[\w*-]+|[a-z-]+)\s*:([\s\S]*)$/.exec(statement);
-    if (declaration && stack.length > 0) {
-      result.declarations.push({
-        property: declaration[1],
-        value: declaration[2].trim().replaceAll(/\s+/g, " "),
-        context: stack.map((entry) => entry.prelude),
-        comment: commentBefore(css, comments, position)
-      });
-    }
-  };
-  for (let index = 0; index < css.length; index++) {
-    const char = css[index];
-    if (quote) {
-      if (char === quote && css[index - 1] !== "\\")
-        quote = void 0;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-    } else if (char === "(") {
-      parens++;
-    } else if (char === ")") {
-      parens = Math.max(0, parens - 1);
-    } else if (parens > 0) {
-      continue;
-    } else if (char === ";") {
-      flush(index);
-      start = index + 1;
-    } else if (char === "{") {
-      stack.push({ prelude: css.slice(start, index).trim().replaceAll(/\s+/g, " "), open: index });
-      start = index + 1;
-    } else if (char === "}") {
-      flush(index);
-      start = index + 1;
-      const block = stack.pop();
-      if (block && BLOCK_AT_RULES.test(block.prelude))
-        result.blocks.push({ prelude: block.prelude, body: css.slice(block.open + 1, index).trim().replaceAll(/\s+/g, " ") });
-    }
-  }
-  return result;
-}
-const NAMESPACES = [
-  { prefix: "--color-", topic: "colors", usage: (name) => `bg-${name} text-${name} border-${name}...` },
-  { prefix: "--font-weight-", topic: "typography", usage: (name) => `font-${name}` },
-  { prefix: "--font-", topic: "typography", usage: (name) => `font-${name}` },
-  { prefix: "--text-shadow-", topic: "shadows", usage: (name) => `text-shadow-${name}` },
-  { prefix: "--text-", topic: "typography", usage: (name) => `text-${name}` },
-  { prefix: "--tracking-", topic: "typography", usage: (name) => `tracking-${name}` },
-  { prefix: "--leading-", topic: "typography", usage: (name) => `leading-${name}` },
-  { prefix: "--animate-", topic: "typography", usage: (name) => `animate-${name}` },
-  { prefix: "--ease-", topic: "typography", usage: (name) => `ease-${name}` },
-  { prefix: "--duration-", topic: "typography", usage: (name) => `duration-(--duration-${name})` },
-  { prefix: "--radius-", topic: "radius", usage: (name) => `rounded-${name}` },
-  { prefix: "--inset-shadow-", topic: "shadows", usage: (name) => `inset-shadow-${name}` },
-  { prefix: "--drop-shadow-", topic: "shadows", usage: (name) => `drop-shadow-${name}` },
-  { prefix: "--shadow-", topic: "shadows", usage: (name) => `shadow-${name}` },
-  { prefix: "--spacing-", topic: "spacing", usage: (name) => `p-${name} gap-${name} w-${name}...` },
-  { prefix: "--breakpoint-", topic: "breakpoints", usage: (name) => `${name}:` },
-  { prefix: "--container-", topic: "layout", usage: (name) => `max-w-${name} @${name}:` },
-  { prefix: "--aspect-", topic: "layout", usage: (name) => `aspect-${name}` },
-  { prefix: "--z-", topic: "z-index", usage: (name) => `z-${name}` }
-];
-function tokenOf(variable, value, { inline = false, comment } = {}) {
-  if (variable === "--spacing")
-    return { variable, value, topic: "spacing", usage: "p-4 gap-2 w-8... (base step)", inline, comment };
-  const namespace = NAMESPACES.find((entry) => variable.startsWith(entry.prefix));
-  return namespace ? { variable, value, topic: namespace.topic, usage: namespace.usage(variable.slice(namespace.prefix.length)), inline, comment } : { variable, value, topic: "css-variables", usage: `var(${variable})`, inline, comment };
-}
-function importPath(statement) {
-  return /^@import\s+(?:url\()?\s*["']([^"']+)["']/.exec(statement)?.[1];
-}
-function themeContext(context) {
-  return context.find((prelude) => /^@theme\b/.test(prelude));
-}
-function readStylesheet(file, source) {
-  const { declarations, statements, blocks } = parseCss(source);
-  const stylesheet = { file, imports: [], tokens: [], resets: [], variants: [], utilities: [], keyframes: [], mazVariables: [] };
-  for (const statement of statements) {
-    const path = importPath(statement);
-    const variant = /^@custom-variant ([\w-]+) (.+)$/.exec(statement);
-    if (path)
-      stylesheet.imports.push(path);
-    else if (variant)
-      stylesheet.variants.push({ name: variant[1], definition: variant[2] });
-  }
-  for (const { prelude, body } of blocks) {
-    const [, kind, name] = /^@([\w-]+) ([\w*-]+)/.exec(prelude) ?? [];
-    if (kind === "utility")
-      stylesheet.utilities.push({ name, css: body });
-    else if (kind === "keyframes")
-      stylesheet.keyframes.push(name);
-    else if (kind === "custom-variant")
-      stylesheet.variants.push({ name, definition: `{ ${body} }` });
-  }
-  for (const { property, value, context, comment } of declarations) {
-    const theme = themeContext(context);
-    if (theme && property.startsWith("--")) {
-      if (value === "initial")
-        stylesheet.resets.push(property);
-      else if (!/^--[\w-]+--/.test(property))
-        stylesheet.tokens.push(tokenOf(property, value, { inline: /\binline\b/.test(theme), comment }));
-    } else if (!theme && property.startsWith("--maz-")) {
-      stylesheet.mazVariables.push({ variable: property, value, selector: context.filter((prelude) => !prelude.startsWith("@layer")).join(" ") });
-    }
-  }
-  return stylesheet;
-}
-function isTailwindStylesheet(source) {
-  return /@import\s+(?:url\()?\s*["'](?:tailwindcss|maz-ui\/tailwindcss)/.test(source) || /@(?:theme|custom-variant|utility)\b/.test(source);
-}
-
-const IGNORED = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/coverage/**",
-  "**/public/**",
-  "**/.*/**",
-  "**/*.min.css",
-  "**/*.d.ts",
-  "**/*.{spec,test}.*"
-];
-const MAX_FILE_SIZE = 3e5;
-const PATTERNS = ["*.css", "*.ts", "*.mts", "*.cts", "*.js", "*.mjs"];
-const IGNORED_PATH = /(?:^|\/)(?:node_modules|dist|build|coverage|public|fixtures|__tests__|\.[^/]+)\/|\.min\.css$|\.d\.ts$|\.(?:spec|test)\.\w+$/;
-function projectFiles(rootDir) {
-  try {
-    return execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard", "--", ...PATTERNS], { cwd: rootDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 }).split("\n").filter((file) => file && !IGNORED_PATH.test(file));
-  } catch {
-    return globSync(PATTERNS.map((pattern) => `**/${pattern}`), { cwd: rootDir, ignore: IGNORED, deep: 8 }).filter((file) => !IGNORED_PATH.test(file));
-  }
-}
-function readSmallFile(path) {
-  try {
-    return statSync(path).size <= MAX_FILE_SIZE ? readFileSync(path, "utf8") : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function readProjectTheme(rootDir) {
-  if (!existsSync(join(rootDir, "package.json")))
-    return { stylesheets: [], presets: [] };
-  const files = projectFiles(rootDir).sort();
-  const theme = { stylesheets: [], presets: [] };
-  for (const file of files) {
-    const source = readSmallFile(join(rootDir, file));
-    if (!source)
-      continue;
-    if (file.endsWith(".css")) {
-      if (isTailwindStylesheet(source))
-        theme.stylesheets.push(readStylesheet(file, source));
-    } else if (source.includes("definePreset(")) {
-      theme.presets.push(...readPresets(file, source));
-    }
-  }
-  return theme;
-}
-const FOUNDATION_USAGE = {
-  "base-font-size": { topic: "typography", usage: "root font size: every `rem` and the `text-*` sizes" },
-  "border-width": { topic: "typography", usage: "`border` (default width)" },
-  "font-family": { topic: "typography", usage: "`font-sans` (default font)" },
-  "font-mono-stack": { topic: "typography", usage: "`font-mono`" },
-  "font-display-stack": { topic: "typography", usage: "`font-display`" },
-  "motion-fast": { topic: "typography", usage: "`duration-(--duration-fast)`" },
-  "motion-normal": { topic: "typography", usage: "`duration-(--duration-normal)` and the default transition duration" },
-  "motion-slow": { topic: "typography", usage: "`duration-(--duration-slow)`" },
-  "easing-out": { topic: "typography", usage: "`ease-out` and the default transition easing" },
-  "easing-in": { topic: "typography", usage: "`ease-in`" },
-  "easing-in-out": { topic: "typography", usage: "`ease-in-out`" },
-  "disabled-opacity": { topic: "utilities", usage: "`disabled-opacity`, `disabled-state`" },
-  "disabled-cursor": { topic: "utilities", usage: "`disabled-cursor`, `disabled-state`" },
-  "space": { topic: "spacing", usage: "every spacing utility (`p-4` = 4 x space)" }
-};
-const COMPONENT_USAGE = {
-  "btn.font-weight": "font weight of MazBtn",
-  "container.bg": "`bg-container`: MazCard, MazContainer, MazDialog, MazPopover, MazDrawer...",
-  "input.bg": "`bg-input`: MazInput, MazSelect, MazTextarea, MazCheckbox...",
-  "input.top-label-font-weight": "font weight of the `top-label` of the inputs",
-  "dialog.max-width": "max width of MazDialog",
-  "dialog.min-width": "min width of MazDialog"
-};
-function code(value) {
-  return `\`${value.replaceAll("`", "'").replaceAll("|", "\\|")}\``;
-}
-function shorten(value, max = 70) {
-  return value.length > max ? `${value.slice(0, max - 3)}...` : value;
-}
-function display(value) {
-  if (value === void 0)
-    return "-";
-  return code(shorten(typeof value === "object" && value !== null ? JSON.stringify(value) : String(value)));
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-const COLOR_CLASSES = {
-  shadow: "`shadow-shadow/20`",
-  overlay: "`bg-overlay`",
-  divider: "`border-divider`"
-};
-function colorClasses(name) {
-  if (COLOR_CLASSES[name])
-    return COLOR_CLASSES[name];
-  return name.endsWith("-foreground") ? code(`text-${name}`) : `${code(`bg-${name}`)} ${code(`text-${name}`)}`;
-}
-function presetColors(preset) {
-  const colors = asRecord(preset.overrides.colors);
-  const light = asRecord(colors.light);
-  const dark = asRecord(colors.dark);
-  const names = [.../* @__PURE__ */ new Set([...Object.keys(light), ...Object.keys(dark)])];
-  if (names.length === 0)
-    return [];
-  return [
-    "| Color | Classes | Light | Dark |",
-    "| --- | --- | --- | --- |",
-    ...names.map((name) => `| \`${name}\` | ${colorClasses(name)} | ${display(light[name])} | ${display(dark[name])} |`)
-  ];
-}
-function presetFoundation(preset, wanted) {
-  const rows = Object.entries(asRecord(preset.overrides.foundation)).filter(([key]) => wanted(FOUNDATION_USAGE[key]?.topic ?? "css-variables")).map(([key, value]) => `| \`${key}\` | \`--maz-${key}\` | ${FOUNDATION_USAGE[key]?.usage ?? "-"} | ${display(value)} |`);
-  return rows.length > 0 ? ["| Foundation | CSS variable | Used by | Value |", "| --- | --- | --- | --- |", ...rows] : [];
-}
-function presetScales(preset, wanted) {
-  const scales = asRecord(preset.overrides.scales);
-  const rows = [
-    ...wanted("radius") ? Object.entries(asRecord(scales.rounded)).map(([key, value]) => `| ${code(`rounded-${key}`)} | ${display(value)} |`) : [],
-    ...wanted("shadows") ? Object.entries(asRecord(scales.shadow)).map(([key, value]) => `| ${code(`shadow-${key}`)} | ${display(value)} |`) : []
-  ];
-  return rows.length > 0 ? ["| Class | Value |", "| --- | --- |", ...rows] : [];
-}
-function flatten(value, path) {
-  const record = asRecord(value);
-  const keys = Object.keys(record);
-  if (keys.length === 0 || keys.every((key) => key === "light" || key === "dark"))
-    return [[path, value]];
-  return keys.flatMap((key) => flatten(record[key], path ? `${path}.${key}` : key));
-}
-function presetComponents(preset) {
-  const rows = flatten(asRecord(preset.overrides.components), "").filter(([path]) => path).map(([path, value]) => `| \`components.${path}\` | ${COMPONENT_USAGE[path] ?? "-"} | ${display(value)} |`);
-  return rows.length > 0 ? ["| Component token | Used by | Value |", "| --- | --- | --- |", ...rows] : [];
-}
-function renderPreset(preset, wanted, filtered) {
-  const name = typeof preset.overrides.name === "string" ? ` \`${preset.overrides.name}\`` : "";
-  const origin = [preset.exportName && `\`${preset.exportName}\``, preset.base && `base \`${preset.base}\``].filter(Boolean).join(", ");
-  const tables = [
-    wanted("colors") ? presetColors(preset) : [],
-    presetFoundation(preset, wanted),
-    presetScales(preset, wanted),
-    wanted("colors") ? presetComponents(preset) : []
-  ].filter((table) => table.length > 0);
-  if (filtered && tables.length === 0)
-    return void 0;
-  return [
-    `### Preset${name} - \`${preset.file}\`${origin ? ` (${origin})` : ""}`,
-    "The preset sets the **values** of the maz-ui tokens at runtime, the class names stay the same: `bg-primary` uses the preset `primary`, `font-display` the preset `font-display-stack`. Brand colors, fonts, radius, shadows and motion belong here, not in CSS.",
-    ...tables.map((table) => table.join("\n"))
-  ].join("\n\n");
-}
-function mazUiThemeVariables(tailwind) {
-  const variables = /* @__PURE__ */ new Map();
-  const named = (entries, toVariable) => {
-    for (const entry of entries) variables.set(toVariable(entry.name), entry.value);
-  };
-  for (const color of tailwind.colors) variables.set(`--color-${color.name}`, `var(${color.variable})`);
-  named(tailwind.fonts, (name) => `--${name}`);
-  named(tailwind.radius, (name) => name.replace(/^rounded-/, "--radius-"));
-  named(tailwind.shadows, (name) => `--${name}`);
-  named(tailwind.breakpoints, (name) => `--breakpoint-${name.replace(/:$/, "")}`);
-  named(tailwind.easings, (name) => `--${name}`);
-  named(tailwind.zIndex, (name) => `--${name}`);
-  named(tailwind.durations, (name) => /--duration-[\w-]+/.exec(name)?.[0] ?? name);
-  return variables;
-}
-function tokenNote(token, mazUi) {
-  const original = mazUi.get(token.variable);
-  const notes = [
-    token.comment,
-    original && original !== token.value ? `Redefines the maz-ui token (maz-ui: ${code(shorten(original, 50))}): this class no longer follows the preset.` : void 0
-  ];
-  return notes.filter(Boolean).join(" ").replaceAll("|", "\\|") || "-";
-}
-function renderStylesheet(stylesheet, mazUi, wanted, animated) {
-  const sections = [];
-  const problems = stylesheetProblems(stylesheet);
-  if (problems.length > 0)
-    sections.push(problems.map((problem) => `> ${problem}`).join("\n>\n"));
-  const tokens = stylesheet.tokens.filter((token) => wanted(token.topic));
-  if (tokens.length > 0) {
-    sections.push([
-      `#### Project tokens (\`@theme\`)`,
-      "",
-      "| Classes | Variable | Value | Note |",
-      "| --- | --- | --- | --- |",
-      ...tokens.map((token) => `| ${code(token.usage)} | \`${token.variable}\` | ${code(shorten(token.value, 60))} | ${tokenNote(token, mazUi)} |`)
-    ].join("\n"));
-  }
-  if (stylesheet.resets.length > 0 && wanted("colors"))
-    sections.push(`Reset namespaces: ${stylesheet.resets.map((reset) => code(reset)).join(", ")}: the default Tailwind tokens of these namespaces do not exist.`);
-  if (stylesheet.variants.length > 0 && (wanted("variants") || wanted("breakpoints")))
-    sections.push(["#### Custom variants", "", "| Variant | Definition |", "| --- | --- |", ...stylesheet.variants.map((variant) => `| \`${variant.name}:\` | ${code(shorten(variant.definition))} |`)].join("\n"));
-  if (stylesheet.utilities.length > 0 && wanted("utilities"))
-    sections.push(["#### Custom utilities", "", "| Class | CSS |", "| --- | --- |", ...stylesheet.utilities.map((utility) => `| \`${utility.name}\` | ${code(shorten(utility.css))} |`)].join("\n"));
-  const keyframes = stylesheet.keyframes.filter((name) => !animated.has(name));
-  if (keyframes.length > 0 && wanted("typography"))
-    sections.push(`Keyframes without \`animate-*\` token: ${keyframes.map((name) => code(name)).join(", ")}. Use them in CSS or add a \`--animate-<name>\` token to the \`@theme\` to get a class.`);
-  if (stylesheet.mazVariables.length > 0 && (wanted("layout") || wanted("css-variables"))) {
-    sections.push([
-      "#### maz-ui variables set in CSS",
-      "",
-      "| Variable | Value | Selector |",
-      "| --- | --- | --- |",
-      ...stylesheet.mazVariables.map((variable) => `| \`${variable.variable}\` | ${code(shorten(variable.value, 50))} | ${code(variable.selector)} |`)
-    ].join("\n"));
-  }
-  return sections;
-}
-function renderStylesheetSection(stylesheet, mazUi, topics, animated) {
-  const sections = renderStylesheet(stylesheet, mazUi, (topic) => !topics?.length || topics.includes(topic), animated);
-  if (topics?.length && sections.length === 0)
-    return void 0;
-  const imports = stylesheet.imports.length > 0 ? [`Imports: ${stylesheet.imports.map((path) => code(path)).join(", ")}`] : [];
-  return [`### Tailwind \`${stylesheet.file}\``, ...imports, ...sections].join("\n\n");
-}
-function stylesheetProblems(stylesheet) {
-  if (!stylesheet.imports.includes("tailwindcss"))
-    return [];
-  const mazUiImports = stylesheet.imports.filter((path) => path.startsWith("maz-ui/tailwindcss"));
-  const problems = [];
-  if (mazUiImports.length === 0)
-    problems.push("The maz-ui theme is not imported: `bg-primary`, `rounded-md`, `mob-m:`... do not exist. Add `@import 'maz-ui/tailwindcss/theme.css';` after `@import 'tailwindcss';`.");
-  else if (!mazUiImports.includes("maz-ui/tailwindcss/utilities.css"))
-    problems.push("`maz-ui/tailwindcss/utilities.css` is not imported: `flex-center`, `padded-container`, `disabled-state`... do not exist.");
-  return problems;
-}
-const HOW_IT_WORKS = `How your theme combines with maz-ui:
-
-1. **The preset** (\`definePreset\` of \`@maz-ui/themes\`) sets the runtime values of the maz-ui tokens (\`--maz-*\`): brand colors, fonts, radius, shadows, motion. The maz-ui classes keep their names and follow it, in light and dark mode.
-2. **The Tailwind entry** imports the maz-ui theme, then extends it with \`@theme\` tokens (each one generates classes: \`--animate-rise\` -> \`animate-rise\`, \`--font-display\` -> \`font-display\`), \`@custom-variant\` and \`@utility\`.
-3. **Pick classes in this order**: the project tokens below for project-specific needs, then the maz-ui classes, never the default Tailwind palette, hard-coded values or arbitrary values. When a value is missing, add a token to the project \`@theme\` (or a brand value to the preset) and use its class.`;
-function renderProjectTheme(theme, tailwind, topics) {
-  if (theme.stylesheets.length === 0 && theme.presets.length === 0)
-    return void 0;
-  const wanted = (topic) => !topics?.length || topics.includes(topic);
-  const mazUi = mazUiThemeVariables(tailwind);
-  const animated = new Set(theme.stylesheets.flatMap((stylesheet) => stylesheet.tokens.filter((token) => token.variable.startsWith("--animate-")).map((token) => token.value.split(/\s/)[0])));
-  return [
-    "## Your project theme",
-    HOW_IT_WORKS,
-    ...theme.presets.map((preset) => renderPreset(preset, wanted, !!topics?.length)),
-    ...theme.stylesheets.map((stylesheet) => renderStylesheetSection(stylesheet, mazUi, topics, animated))
-  ].filter(Boolean).join("\n\n");
-}
-
-const THEME_TOPICS = {
-  "setup": "Setup",
-  "colors": "Colors",
-  "radius": "Border radius",
-  "shadows": "Shadows",
-  "spacing": "Spacing",
-  "breakpoints": "Breakpoints",
-  "typography": "Typography and motion",
-  "z-index": "z-index",
-  "utilities": "Custom utilities",
-  "variants": "Variants",
-  "layout": "Layout variables",
-  "transitions": "Vue transitions",
-  "css-variables": "CSS variables in custom CSS"
-};
-function getThemeTokens(context, { topics, project = true }) {
-  const reference = context.knowledge.docsById.get("reference/tailwind-tokens");
-  if (!reference)
-    throw new ToolInputError('This maz-ui version does not ship the Tailwind reference. Read `get_doc({ id: "guide/tailwind" })`.');
-  const markdown = stripFrontmatter(context.knowledge.readDoc(reference.id));
-  const projectTheme = project ? renderProjectTheme(readProjectTheme(context.cwd), context.knowledge.manifest.tailwind, topics) : void 0;
-  const footer = '\n\nHow to extend the theme (project colors, fonts, animations, variants, utilities, container width) and how it combines with the preset: `get_doc({ id: "guide/tailwind" })`. Brand colors, fonts and radius belong to a preset: `get_doc({ id: "ecosystem/themes", sections: ["Creating Custom Themes"] })`.';
-  const mazUiTheme = topics?.length ? `# maz-ui ${context.knowledge.version} Tailwind theme
-
-${topics.map((topic) => {
-    const section = findSection(markdown, THEME_TOPICS[topic]);
-    return section ? sectionContent(markdown, section) : "";
-  }).filter(Boolean).join("\n\n")}` : markdown.trim();
-  return projectTheme ? `${projectTheme}
-
----
-
-${mazUiTheme}${footer}` : `${mazUiTheme}${footer}`;
-}
-const getThemeTokensTool = defineTool({
-  name: "get_theme_tokens",
-  title: "maz-ui Tailwind theme tokens",
-  description: "The Tailwind theme of the project: its own tokens, preset, variants and utilities (read from its Tailwind entry and `definePreset`), then every Tailwind CSS class and CSS variable of the maz-ui theme (installed version): theme colors (bg-primary, text-muted, border-divider, bg-surface... with -foreground and 50-950 scales), radius, shadows (shadow-elevation), spacing, breakpoints (mob-*, tab-*, lap-*), fonts, durations, z-index, custom utilities (flex-center, padded-container), dark variant and CSS variables. Use it before styling: never the default Tailwind palette, hard-coded colors or the internal `maz:` prefix.",
-  inputSchema: {
-    topics: z.array(z.enum(Object.keys(THEME_TOPICS))).optional().describe("Only these topics (default: everything)"),
-    project: z.boolean().optional().describe("Include the theme of the project: preset, `@theme` tokens, variants, utilities (default: true)")
-  },
-  run: getThemeTokens
-});
-
-const LEGEND = "Fix every error and warning (info are suggestions). If a native element or a rule is intended, add a `maz-ui-review-ignore [rule]` comment on the line above.";
-async function reviewCodeTool(context, { paths, code, filename, framework, minSeverity = "info" }) {
-  if (!paths?.length && !code)
-    throw new ToolInputError("Pass `paths` (files, folders or globs, relative to the project) or `code` (with `filename` to pick the parser).");
-  const sections = [];
-  if (code) {
-    const findings = filterBySeverity(
-      reviewCode(code, { knowledge: context.knowledge, filename, framework: framework ?? detectFramework(context.cwd) }),
-      minSeverity
-    );
-    sections.push(formatFindings(findings, filename ?? "code"));
-  }
-  if (paths?.length) {
-    const { reviews, truncated } = await reviewFiles(paths, { knowledge: context.knowledge, cwd: context.cwd, framework, minSeverity });
-    if (reviews.length === 0)
-      throw new ToolInputError(`No .vue, .ts, .js or .css file matches ${paths.join(", ")} (from ${context.cwd}).`);
-    const withIssues = reviews.filter((review) => review.findings.length > 0);
-    const totals = countBySeverity(reviews.flatMap((review) => review.findings));
-    sections.push(`Reviewed ${reviews.length} file${reviews.length > 1 ? "s" : ""}: ${totals.error} errors, ${totals.warning} warnings, ${totals.info} info.${truncated ? ` Only the first ${MAX_REVIEWED_FILES} files were reviewed: narrow the paths.` : ""}`);
-    sections.push(...withIssues.map((review) => formatFindings(review.findings, review.file)));
-  }
-  return `# maz-ui review (maz-ui ${context.knowledge.version})
-
-${sections.join("\n\n")}
-
-${LEGEND}`;
-}
-const reviewCodeToolDefinition = defineTool({
-  name: "review_code",
-  title: "Review code against maz-ui",
-  description: "Static review of Vue SFCs, TS/JS and CSS against the installed maz-ui: unknown components, props, v-model, events or slots, invalid prop values, unknown icons, native elements or third-party libraries that maz-ui already covers (buttons, inputs, dialogs, toasts, icons, date pickers, lodash debounce...), default Tailwind palette and hard-coded colors instead of theme tokens, the internal `maz:` prefix, Tailwind v3 utilities, manual dark mode, wrong imports. Run it on the files you created or changed before finishing.",
-  inputSchema: {
-    paths: z.array(z.string()).max(50).optional().describe('Files, folders or globs relative to the project root: ["src/components/LoginForm.vue", "app/pages/**/*.vue"]'),
-    code: z.string().optional().describe("Source to review when it is not on disk"),
-    filename: z.string().optional().describe('Name of `code` (e.g. "Card.vue") to select the parser'),
-    framework: z.enum(["vue", "nuxt"]).optional().describe("Detected from nuxt.config when omitted"),
-    minSeverity: z.enum(["error", "warning", "info"]).optional().describe("Hide findings below this severity (default info)")
-  },
-  run: reviewCodeTool
-});
-
-const TOOLS = [
-  searchDocsTool,
-  getComponentApiTool,
-  findIconsTool,
-  getThemeTokensTool,
-  getDocTool,
-  listDocsTool,
-  getSetupGuideTool,
-  reviewCodeToolDefinition
-];
-async function runTool(context, tool, args) {
-  try {
-    return { content: [{ type: "text", text: await tool.run(context, args) }] };
-  } catch (error) {
-    const message = error instanceof ToolInputError ? error.message : `Unexpected error in ${tool.name}: ${getErrorMessage(error)}. Retry with other arguments or fall back to the docs in node_modules/maz-ui/docs.`;
-    return { content: [{ type: "text", text: message }], isError: true };
-  }
-}
-function createMazUiMcpServer(options = {}) {
-  const context = createContext(options);
-  const server = new McpServer(
-    { name: "maz-ui", title: "maz-ui", version: readOwnVersion() },
-    { instructions: buildInstructions(context) }
-  );
-  for (const tool of TOOLS) {
-    server.registerTool(tool.name, {
-      title: tool.title,
-      description: tool.description,
-      inputSchema: tool.inputSchema,
-      annotations: {
-        title: tool.title,
-        readOnlyHint: true,
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: false
-      },
-      _meta: { "anthropic/maxResultSizeChars": 8e4 }
-    }, (args) => runTool(context, tool, args));
-  }
-  registerPrompts(server);
-  return { server, context };
-}
-async function startStdioServer(options = {}) {
-  const { server } = createMazUiMcpServer(options);
-  await server.connect(new StdioServerTransport());
-  return server;
-}
-
-const HELP = `maz-ui-mcp: maz-ui knowledge for AI coding agents
-
-Usage:
-  maz-ui-mcp [serve] [--docs <dir>]   Start the MCP server (stdio)
-  maz-ui-mcp init [options]           Configure the AI agents of this project for maz-ui
-  maz-ui-mcp review <paths...>        Review files against maz-ui (CI friendly)
-  maz-ui-mcp search <query>           Search the maz-ui docs from the terminal
-
-init options:
-  --targets <list>    Comma separated: ${AGENT_TARGETS.join(", ")} (default: detected, else claude,agents-md)
-  --no-rules          Only register the MCP server (no rule file, no AGENTS.md section)
-  --no-mcp            Do not register the MCP server
-  --dry-run           Show the changes without writing them
-  --remove            Remove what init added
-
-review options:
-  --min-severity <s>  error | warning | info (default info)
-  --framework <f>     vue | nuxt (default: detected)
-  --format <f>        text | json (default text)
-  --max-warnings <n>  Exit with an error above this number of warnings
-  --hook              Claude Code PostToolUse hook mode (reads the edited file from stdin)
-
-Common options:
-  --docs <dir>        Use this docs bundle instead of the maz-ui installed in the project
-  --cwd <dir>         Project root (default: current directory)
-  -v, --version
-  -h, --help
-`;
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  return Buffer.concat(chunks).toString("utf8");
-}
-function printChanges(changes, dryRun) {
-  const labels = {
-    create: dryRun ? "would create" : "created",
-    update: dryRun ? "would update" : "updated",
-    remove: dryRun ? "would remove" : "removed",
-    unchanged: "up to date",
-    skip: "skipped"
-  };
-  for (const change of changes) {
-    console.log(`  ${labels[change.action].padEnd(13)} ${change.file}${change.reason ? ` (${change.reason})` : ""}`);
-  }
-}
-function runInit(values, cwd) {
-  const requested = typeof values.targets === "string" ? values.targets.split(",").map((target) => target.trim()).filter(Boolean) : void 0;
-  const invalid = requested?.filter((target) => !AGENT_TARGETS.includes(target)) ?? [];
-  if (invalid.length > 0) {
-    console.error(`Unknown target(s): ${invalid.join(", ")}. Available: ${AGENT_TARGETS.join(", ")}.`);
-    return 1;
-  }
-  const detected = detectAgentTargets(cwd);
-  const targets = requested ?? (detected.length > 0 ? detected : ["claude", "agents-md"]);
-  const dryRun = values["dry-run"] === true;
-  const result = setupAgents({
-    rootDir: cwd,
-    targets,
-    rules: values["no-rules"] !== true,
-    mcp: values["no-mcp"] !== true,
-    dryRun,
-    remove: values.remove === true,
-    docsDir: typeof values.docs === "string" ? resolve(values.docs) : void 0
-  });
-  console.log(`maz-ui ${result.version ? `${result.version} ` : ""}agents setup (${targets.join(", ")})${dryRun ? " - dry run" : ""}`);
-  printChanges(result.changes, dryRun);
-  if (!values.remove && values["no-rules"] !== true && targets.includes("agents-md"))
-    console.log("\nCodex and Windsurf read AGENTS.md. To give them the MCP server too, add `npx -y @maz-ui/mcp@latest` to their global MCP config.");
-  return 0;
-}
-async function runReview(values, positionals, cwd) {
-  const context = createContext({ cwd, docsDir: typeof values.docs === "string" ? resolve(values.docs) : void 0 });
-  const framework = values.framework;
-  if (values.hook) {
-    const input = JSON.parse(await readStdin() || "{}");
-    const file = input.tool_input?.file_path;
-    if (!file || !REVIEWABLE_EXTENSIONS.includes(file.split(".").pop() ?? "") || /[\\/](?:node_modules|dist|\.nuxt|\.output)[\\/]/.test(file))
-      return 0;
-    const { reviews: reviews2 } = await reviewFiles([file], { knowledge: context.knowledge, cwd: input.cwd ?? cwd, framework, minSeverity: "warning" });
-    const findings = reviews2.flatMap((review) => review.findings);
-    if (findings.length === 0)
-      return 0;
-    console.error(`${formatFindings(findings, reviews2[0].file)}
-
-Fix these maz-ui issues (see the maz-ui MCP tools), or add a \`maz-ui-review-ignore <rule> -- <reason>\` comment above the line when it is intended.`);
-    return 2;
-  }
-  if (positionals.length === 0) {
-    console.error('Pass the files, folders or globs to review: maz-ui-mcp review "src/**/*.vue"');
-    return 1;
-  }
-  const { reviews, truncated } = await reviewFiles(positionals, {
-    knowledge: context.knowledge,
-    cwd,
-    framework,
-    minSeverity: values["min-severity"] ?? "info"
-  });
-  const totals = countBySeverity(reviews.flatMap((review) => review.findings));
-  if (values.format === "json") {
-    console.log(JSON.stringify({ version: context.knowledge.version, totals, truncated, files: reviews }, null, 2));
-  } else {
-    for (const review of reviews.filter((entry) => entry.findings.length > 0)) console.log(`${formatFindings(review.findings, review.file)}
-`);
-    console.log(`${reviews.length} file(s) reviewed against maz-ui ${context.knowledge.version}: ${totals.error} error(s), ${totals.warning} warning(s), ${totals.info} info.`);
-  }
-  const maxWarnings = values["max-warnings"] === void 0 ? Number.POSITIVE_INFINITY : Number(values["max-warnings"]);
-  return totals.error > 0 || totals.warning > maxWarnings ? 1 : 0;
-}
-async function runCli(argv = process.argv.slice(2)) {
-  const { values, positionals } = parseArgs({
-    args: argv,
-    allowPositionals: true,
-    strict: true,
-    options: {
-      "docs": { type: "string" },
-      "cwd": { type: "string" },
-      "targets": { type: "string" },
-      "no-rules": { type: "boolean" },
-      "no-mcp": { type: "boolean" },
-      "dry-run": { type: "boolean" },
-      "remove": { type: "boolean" },
-      "min-severity": { type: "string" },
-      "framework": { type: "string" },
-      "format": { type: "string" },
-      "max-warnings": { type: "string" },
-      "hook": { type: "boolean" },
-      "version": { type: "boolean", short: "v" },
-      "help": { type: "boolean", short: "h" }
-    }
-  });
-  const [command = "serve", ...rest] = positionals;
-  const cwd = resolve(values.cwd ?? process.cwd());
-  if (values.help) {
-    console.log(HELP);
-    return 0;
-  }
-  if (values.version) {
-    console.log(readOwnVersion());
-    return 0;
-  }
-  switch (command) {
-    case "serve":
-      await startStdioServer({ cwd, docsDir: values.docs ? resolve(values.docs) : void 0 });
-      return -1;
-    case "init":
-      return runInit(values, cwd);
-    case "review":
-      return runReview(values, rest, cwd);
-    case "search": {
-      const context = createContext({ cwd, docsDir: values.docs ? resolve(values.docs) : void 0 });
-      console.log(searchDocs(context, { query: rest.join(" ") || "button" }));
-      return 0;
-    }
-    default:
-      console.error(`Unknown command "${command}".
-
-${HELP}`);
-      return 1;
-  }
-}
-async function main() {
-  try {
-    const code = await runCli();
-    if (code >= 0)
-      process.exitCode = code;
-  } catch (error) {
-    console.error(getErrorMessage(error));
-    process.exitCode = 1;
-  }
-}
-
-export { DocSearch as D, HELP as H, Knowledge as K, TOOLS as T, createContext as a, buildInstructions as b, countBySeverity as c, createMazUiMcpServer as d, findProjectMazUi as e, filterBySeverity as f, formatFindings as g, reviewFiles as h, runCli as i, startStdioServer as j, runInit as k, loadKnowledge as l, main as m, runReview as n, reviewCode as r, searchIcons as s };