@walkeros/explorer 4.7.2 → 4.8.0-next-1791496487198

package/dist/design/check.mjs

@@ -0,0 +1,628 @@
+#!/usr/bin/env node
+
+// src/design/check/bin.ts
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/design/check/cli.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { extname, join, relative, resolve, sep } from "node:path";
+
+// src/design/names.ts
+var DECLARATION = /(?<![A-Za-z0-9_-])--([A-Za-z0-9_-]+)['"]?\s*:/g;
+var SET_PROPERTY = /setProperty\(\s*['"`]--([A-Za-z0-9_-]+)/g;
+function forEachMatch(pattern, text, visit) {
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  const re = new RegExp(pattern.source, flags);
+  for (let match = re.exec(text); match !== null; match = re.exec(text))
+    visit(match);
+}
+function collectDeclaredNames(text) {
+  const names = /* @__PURE__ */ new Set();
+  forEachMatch(DECLARATION, text, (match) => names.add(match[1]));
+  forEachMatch(SET_PROPERTY, text, (match) => names.add(match[1]));
+  return names;
+}
+
+// src/design/check/glob.ts
+var escape = (text) => text.replace(/[.+^$()|[\]\\{}*?]/g, "\\$&");
+function globToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i++) {
+    const char = glob[i];
+    if (char === "*" && glob[i + 1] === "*") {
+      const slash = glob[i + 2] === "/";
+      source += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else if (char === "{") {
+      const end = glob.indexOf("}", i);
+      if (end === -1) return void 0;
+      source += `(?:${glob.slice(i + 1, end).split(",").map(escape).join("|")})`;
+      i = end;
+    } else {
+      source += escape(char);
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+// src/design/tailwind-namespaces.ts
+var TAILWIND_RESET_NAMESPACES = [
+  "color",
+  "radius",
+  "container",
+  "font",
+  "text",
+  "shadow",
+  "inset-shadow",
+  "drop-shadow",
+  "text-shadow"
+];
+var TAILWIND_KEPT_NAMESPACES = [
+  "animate",
+  "aspect",
+  "blur",
+  "breakpoint",
+  "default",
+  "ease",
+  "font-weight",
+  "leading",
+  "max-width",
+  "perspective",
+  "tracking"
+];
+var TAILWIND_OTHER_NAMESPACES = ["tw", "spacing"];
+var TAILWIND_NESTED_NAMESPACES = [
+  "text-color",
+  "text-decoration-color",
+  "text-decoration-thickness",
+  "text-indent",
+  "text-underline-offset",
+  "font-size"
+];
+var TAILWIND_NAMESPACES = [
+  ...TAILWIND_RESET_NAMESPACES,
+  ...TAILWIND_KEPT_NAMESPACES,
+  ...TAILWIND_OTHER_NAMESPACES,
+  ...TAILWIND_NESTED_NAMESPACES
+];
+var TAILWIND_VARIABLES = [
+  "tw-",
+  ...TAILWIND_KEPT_NAMESPACES.map((namespace) => `${namespace}-`)
+];
+
+// src/design/check/rules.ts
+var RULES = [
+  "color-literal",
+  "named-color",
+  "palette-class",
+  "white-black-class",
+  "dark-variant",
+  "shadow-class",
+  "z-class",
+  "text-size-class",
+  "motion-class",
+  "radius-class",
+  "var-fallback",
+  "undeclared-var",
+  "color-scheme",
+  "z-index",
+  "motion-literal",
+  "font-literal"
+];
+var NAMED_COLORS = new Set(
+  `aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown
+  burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan
+  darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid
+  darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet
+  deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro
+  ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki
+  lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow
+  lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray
+  lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine
+  mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise
+  mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab
+  orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru
+  pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown
+  seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan
+  teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen`.split(
+    /\s+/
+  )
+);
+var PALETTE = "red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|slate|gray|zinc|neutral|stone|mauve|olive|mist|taupe";
+var COLOR_UTILITY = "bg|text|border(?:-[xytrblse])?|outline|ring(?:-offset)?|divide|fill|stroke|from|via|to|placeholder|caret|accent|decoration|shadow|inset-shadow|drop-shadow|text-shadow";
+var START = "(?<![A-Za-z0-9_-])";
+var END = "(?![A-Za-z0-9_-])";
+var SIDE = "(?:-(?:t|r|b|l|s|e|tl|tr|br|bl|ss|se|es|ee))?";
+var LITERAL_ARBITRARY = "\\[(?![^\\]]*var\\()[^\\]\\s]+\\]";
+var CLASS_RULES = [
+  [
+    "palette-class",
+    new RegExp(
+      `${START}(?:${COLOR_UTILITY})-(?:${PALETTE})-(?:50|[1-9]00|950)(?:/\\d+)?${END}`,
+      "g"
+    )
+  ],
+  [
+    "white-black-class",
+    new RegExp(
+      `${START}(?:${COLOR_UTILITY})-(?:white|black)(?:/\\d+)?${END}`,
+      "g"
+    )
+  ],
+  ["dark-variant", new RegExp(`${START}dark:(?=[A-Za-z0-9_\\[!(-])`, "g")],
+  [
+    "shadow-class",
+    // Bare drop-shadow is flagged too (the reset removes it), but not a CSS
+    // drop-shadow() call. Bare shadow is not: "shadow root" prose would fire.
+    new RegExp(
+      `${START}(?:(?:inset-|drop-|text-)?shadow-(?:2xs|xs|sm|md|lg|xl|2xl|inner)${END}|drop-shadow(?![A-Za-z0-9_(-]))`,
+      "g"
+    )
+  ],
+  ["z-class", new RegExp(`${START}-?z-(?:\\d+|\\[-?\\d+\\])${END}`, "g")],
+  // An arbitrary size that reads a variable (`text-[length:var(--type-x-size)]`) is not flagged.
+  [
+    "text-size-class",
+    new RegExp(
+      `${START}text-(?:xs|sm|base|lg|xl|[2-9]xl|\\[(?:length:)?(?![^\\]]*var\\()(?:[\\d.]|(?:calc|clamp|min|max)\\()[^\\]\\s]*\\])${END}`,
+      "g"
+    )
+  ],
+  // Tailwind's transition utilities read --motion and --ease; a zero duration, delay-* and animate-* are not flagged.
+  [
+    "motion-class",
+    new RegExp(
+      `${START}(?:duration-(?:[1-9]\\d*|(?!\\[0m?s\\])${LITERAL_ARBITRARY})|ease-(?:in-out|in|out|linear|${LITERAL_ARBITRARY}))${END}`,
+      "g"
+    )
+  ],
+  // An arbitrary value that reads a design radius (`rounded-[calc(var(--radius-md)-1px)]`) is not flagged.
+  [
+    "radius-class",
+    new RegExp(
+      `${START}rounded${SIDE}(?:-(?:2xl|3xl|4xl|\\[(?![^\\]]*var\\(--radius-)[^\\]\\s]+\\]))?${END}`,
+      "g"
+    )
+  ]
+];
+var STYLE_FILE = /\.(?:css|scss)$/;
+var HEX = /(?<![A-Za-z0-9&#-])#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})(?![A-Za-z0-9-])/g;
+var COLOR_FUNCTION = /(?<![A-Za-z0-9-])(?:rgba?|hsla?|hwb|oklab|oklch|lab|lch)\([^)]*\)/g;
+var CSS_COLOR_FUNCTION = /(?<![A-Za-z0-9_-])color\([^)]*\)/g;
+var STYLE_DECLARATION = /(?<![A-Za-z0-9_-])([a-z-]*(?:color|background|border|outline|fill|stroke|shadow|caret|accent|decoration|column-rule)[a-z-]*)\s*:\s*([^;{}]+)/g;
+var SCRIPT_COLOR_PROPERTY = /(?<![A-Za-z0-9_-])(?:color|background|backgroundColor|borderColor|outlineColor|fill|stroke|caretColor|accentColor)\s*[:=]\s*\{?\s*['"]([A-Za-z]+)['"]/g;
+var WORD = /(?<![A-Za-z0-9_-])[A-Za-z]+(?![A-Za-z0-9_-])/g;
+var URL_FUNCTION = /url\([^)]*\)/g;
+var VAR_REFERENCE = /var\(\s*--([A-Za-z0-9_-]+)\s*(,)?/g;
+var TAILWIND_VAR = /-\(--([A-Za-z0-9_-]+)\)/g;
+var COLOR_SCHEME = /prefers-color-scheme/g;
+var Z_INDEX_CSS = /(?<![A-Za-z0-9_-])z-index\s*:\s*-?\d+/g;
+var Z_INDEX_SCRIPT = /(?<![A-Za-z0-9_-])zIndex\s*:\s*['"]?-?\d+/g;
+var CSS_STYLE = /(?<![A-Za-z0-9_-])(font-size|font-family|font|transition-duration|transition-timing-function|transition)\s*:\s*((?:\$\{[^}]*\}|[^;{}\]])+)/g;
+var SCRIPT_STYLE = /(?<![A-Za-z0-9_-])(fontSize|fontFamily|transitionDuration|transitionTimingFunction|transition)\s*(?::|=\{?)\s*('(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`|\d*\.?\d+(?![\w.]))/g;
+var NUMBER = /^\d*\.?\d+$/;
+var QUOTED = /^(['"`])([\s\S]*)\1$/;
+var MOTION_LITERAL = /(?<![A-Za-z0-9-])(?:cubic-bezier|steps|linear)\([^)]*\)|(?<![A-Za-z0-9.-])(?:(?:\d+(?:\.\d+)?|\.\d+)m?s|ease-in-out|ease-in|ease-out|ease|linear|step-start|step-end)(?![A-Za-z0-9-])/g;
+var LENGTH = "(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:px|rem|em|pt|%|vw|vh|vmin|vmax|ch|ex|lh|rlh|cqw|cqh|cqi)";
+var SIZE_LITERAL = new RegExp(
+  `(?<![A-Za-z0-9.-])(?:${LENGTH}|xxx-large|xx-large|x-large|xx-small|x-small|smaller|small|medium|larger|large)(?![A-Za-z0-9-])`,
+  "g"
+);
+var VARIABLE_DECLARATION = /(?<![A-Za-z0-9_-])(--[A-Za-z0-9_-]+|\$[A-Za-z_][\w-]*)['"]?\s*:\s*['"`]?([^;{}'"`\n\]]+)/g;
+var VARIABLE_READ = /var\(\s*(--[A-Za-z0-9_-]+)|(?<![\w-])(\$[A-Za-z_][\w-]*)/g;
+var MOTION_TOKEN = new RegExp(
+  `var\\(--motion\\)|${MOTION_LITERAL.source}`,
+  "g"
+);
+var FONT_KEYWORD = /(?<![\w-])(?:normal|italic|oblique|small-caps|bold|bolder|lighter|(?:ultra-|extra-|semi-)?(?:condensed|expanded))(?![\w-])/g;
+var FLUID_TYPE = /clamp\((?:[^()]|\([^()]*\))*,\s*var\(--type-[a-z0-9-]+-size\)\s*\)/g;
+var COMMENT = /\/\*[\s\S]*?\*\/|(?<=^|\s)\/\/[^\n]*/g;
+var FONT_FACE = /@font-face\s*\{[^}]*\}/g;
+var CSS_WIDE = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+var STRING_LITERAL = /'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`/g;
+var APPLY = /@apply\s+[^;}]+/g;
+var SCRIPT_TOKEN = new RegExp(
+  `${STRING_LITERAL.source}|\\/\\/[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/`,
+  "g"
+);
+var within = (regions, index) => regions.some(
+  (region) => index >= region.offset && index < region.offset + region.text.length
+);
+function literalFamily(value) {
+  let rest = value.replace(/\$\{[^}]*\}/g, " ").replace(/!important/g, " ");
+  for (let previous = ""; previous !== rest; ) {
+    previous = rest;
+    rest = rest.replace(/var\([^()]*\)/g, " ");
+  }
+  return (rest.match(/[A-Za-z0-9_-]+/g) ?? []).some(
+    (word) => !CSS_WIDE.has(word)
+  );
+}
+function shorthandFamily(value) {
+  return literalFamily(
+    value.replace(SIZE_LITERAL, " ").replace(/(?<![\w.-])\d*\.?\d+(?![\w.])/g, " ").replace(FONT_KEYWORD, " ").replace(/(?<![\w-])(?:calc|clamp|min|max)\(/g, "(").replace(/\//g, " ")
+  );
+}
+var blank = (text) => text.replace(/[^\n]/g, " ");
+function commaItems(value) {
+  const commas = [];
+  let depth = 0;
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === "(") depth++;
+    else if (value[i] === ")") depth--;
+    else if (value[i] === "," && depth === 0) commas.push(i);
+  }
+  return (index) => commas.filter((comma) => comma < index).length;
+}
+function localLiteralLengths(file, text) {
+  const code = STYLE_FILE.test(file) ? text.replace(COMMENT, blank) : text.replace(
+    SCRIPT_TOKEN,
+    (token) => token.startsWith("/") ? blank(token) : token
+  );
+  const names = /* @__PURE__ */ new Set();
+  forEachMatch(VARIABLE_DECLARATION, code, (match) => {
+    if (new RegExp(LENGTH).test(match[2]) && !/var\(|\$/.test(match[2]))
+      names.add(match[1]);
+  });
+  return names;
+}
+function styleValue(property, value, index, { add, motionValues, literalLengths }) {
+  const scanned = value.replace(/\$\{[^}]*\}/g, blank);
+  const bare = QUOTED.exec(value)?.[2] ?? value;
+  const asWritten = value.replace(/\s+/g, " ").trim();
+  if (property.startsWith("transition")) {
+    motionValues.push({ offset: index, text: value });
+    if (NUMBER.test(bare)) {
+      if (property === "transitionDuration")
+        add("motion-literal", index, value);
+      return;
+    }
+    const item = commaItems(value);
+    const timed = /* @__PURE__ */ new Set();
+    forEachMatch(MOTION_TOKEN, scanned, (match) => {
+      const time = /^[\d.]/.test(match[0]);
+      if (time || match[0] === "var(--motion)") {
+        const n = item(match.index);
+        if (property === "transition" && timed.has(n)) return;
+        timed.add(n);
+        if (!time || parseFloat(match[0]) === 0) return;
+      }
+      add("motion-literal", index + match.index, match[0]);
+    });
+  } else if (property === "font-family" || property === "fontFamily") {
+    if (literalFamily(value)) add("font-literal", index, asWritten);
+  } else if (NUMBER.test(bare)) {
+    add("font-literal", index, value);
+  } else {
+    const fluid = [];
+    forEachMatch(
+      FLUID_TYPE,
+      scanned,
+      (match) => fluid.push({ offset: match.index, text: match[0] })
+    );
+    forEachMatch(SIZE_LITERAL, scanned, (match) => {
+      if (!within(fluid, match.index))
+        add("font-literal", index + match.index, match[0]);
+    });
+    forEachMatch(VARIABLE_READ, scanned, (match) => {
+      if (literalLengths.has(match[1] ?? match[2]))
+        add("font-literal", index + match.index, match[0]);
+    });
+    if (property === "font" && shorthandFamily(value))
+      add("font-literal", index, asWritten);
+  }
+}
+function classRegions(style, text) {
+  const regions = [];
+  forEachMatch(
+    style ? APPLY : STRING_LITERAL,
+    text,
+    (match) => regions.push({ offset: match.index, text: match[0] })
+  );
+  return regions;
+}
+function positions(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++)
+    if (text[i] === "\n") starts.push(i + 1);
+  return (index) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = low + high + 1 >> 1;
+      if (starts[mid] <= index) low = mid;
+      else high = mid - 1;
+    }
+    return { line: low + 1, column: index - starts[low] + 1 };
+  };
+}
+function scanFile(file, text, context) {
+  const style = STYLE_FILE.test(file);
+  const position = positions(text);
+  const findings = [];
+  const add = (rule, index, match) => {
+    findings.push({ file, ...position(index), rule, match });
+  };
+  forEachMatch(
+    HEX,
+    text,
+    (match) => add("color-literal", match.index, match[0])
+  );
+  forEachMatch(
+    COLOR_FUNCTION,
+    text,
+    (match) => add("color-literal", match.index, match[0])
+  );
+  if (style) {
+    forEachMatch(
+      CSS_COLOR_FUNCTION,
+      text,
+      (match) => add("color-literal", match.index, match[0])
+    );
+    forEachMatch(STYLE_DECLARATION, text, (match) => {
+      forEachMatch(WORD, match[2].replace(URL_FUNCTION, " "), (word) => {
+        if (NAMED_COLORS.has(word[0].toLowerCase()))
+          add("named-color", match.index, word[0]);
+      });
+    });
+  } else {
+    forEachMatch(SCRIPT_COLOR_PROPERTY, text, (match) => {
+      if (NAMED_COLORS.has(match[1].toLowerCase()))
+        add("named-color", match.index, match[1]);
+    });
+  }
+  const regions = classRegions(style, text);
+  const fontFaces = [];
+  forEachMatch(
+    FONT_FACE,
+    text,
+    (match) => fontFaces.push({ offset: match.index, text: match[0] })
+  );
+  const scan = {
+    add,
+    motionValues: [],
+    literalLengths: context.literalLengths
+  };
+  const cssRegions = style ? [{ offset: 0, text }] : regions;
+  for (const region of cssRegions) {
+    const css = region.text.replace(COMMENT, blank);
+    forEachMatch(CSS_STYLE, css, (match) => {
+      const index = region.offset + match.index + match[0].length - match[2].length;
+      if (!within(fontFaces, index))
+        styleValue(match[1], match[2], index, scan);
+    });
+  }
+  if (!style)
+    forEachMatch(
+      SCRIPT_STYLE,
+      text.replace(
+        SCRIPT_TOKEN,
+        (token) => token.startsWith("/") ? blank(token) : token
+      ),
+      (match) => styleValue(
+        match[1],
+        match[2],
+        match.index + match[0].length - match[2].length,
+        scan
+      )
+    );
+  for (const region of regions) {
+    for (const [rule, pattern] of CLASS_RULES) {
+      forEachMatch(pattern, region.text, (match) => {
+        const index = region.offset + match.index;
+        if (rule !== "motion-class" || !within(scan.motionValues, index))
+          add(rule, index, match[0]);
+      });
+    }
+  }
+  const declared = (name) => context.declaredNames.has(name) || TAILWIND_VARIABLES.some((prefix) => name.startsWith(prefix)) || context.allowVarPrefixes.some((prefix) => name.startsWith(prefix));
+  forEachMatch(VAR_REFERENCE, text, (match) => {
+    const name = match[1];
+    if (context.designNames.has(name)) {
+      if (match[2] === ",") add("var-fallback", match.index, match[0]);
+    } else if (!declared(name)) {
+      add("undeclared-var", match.index, match[0]);
+    }
+  });
+  forEachMatch(TAILWIND_VAR, text, (match) => {
+    if (!context.designNames.has(match[1]) && !declared(match[1])) {
+      add("undeclared-var", match.index + 1, match[0].slice(1));
+    }
+  });
+  forEachMatch(
+    COLOR_SCHEME,
+    text,
+    (match) => add("color-scheme", match.index, match[0])
+  );
+  forEachMatch(
+    Z_INDEX_CSS,
+    text,
+    (match) => add("z-index", match.index, match[0])
+  );
+  if (!style)
+    forEachMatch(
+      Z_INDEX_SCRIPT,
+      text,
+      (match) => add("z-index", match.index, match[0])
+    );
+  return findings.sort(
+    (a, b) => a.line - b.line || a.column - b.column || a.rule.localeCompare(b.rule)
+  );
+}
+
+// src/design/check/cli.ts
+var SCANNED = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".css",
+  ".scss",
+  ".mdx",
+  ".html",
+  ".svg"
+]);
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "storybook-static"
+]);
+var DESIGN_CSS = ["tokens.css", "tailwind.css", "base.css"];
+var USAGE = "usage: walkeros-design-check [--allow [<rule>:]<glob>]... [--allow-var <prefix>]... <path>...";
+var SCOPED = /^([a-z-]+):(.+)$/;
+var isRule = (value) => RULES.some((rule) => rule === value);
+function parseAllow(value) {
+  const scoped = SCOPED.exec(value);
+  if (scoped !== null) {
+    const rule = scoped[1];
+    if (!isRule(rule)) return `unknown rule "${rule}" in --allow ${value}`;
+    const pattern2 = globToRegExp(scoped[2]);
+    return pattern2 === void 0 ? `invalid glob in --allow ${value}` : { rule, pattern: pattern2 };
+  }
+  const pattern = globToRegExp(value);
+  return pattern === void 0 ? `invalid glob in --allow ${value}` : { pattern };
+}
+function usage(io, problem) {
+  io.err(`walkeros-design-check: ${problem}`);
+  io.err(USAGE);
+  return 2;
+}
+function walk(path, into) {
+  if (statSync(path).isFile()) {
+    if (SCANNED.has(extname(path))) into.push(path);
+    return;
+  }
+  const entries = readdirSync(path, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || SKIPPED_DIRS.has(entry.name)) continue;
+    const child = join(path, entry.name);
+    if (entry.isDirectory()) walk(child, into);
+    else if (entry.isFile() && SCANNED.has(extname(entry.name)))
+      into.push(child);
+  }
+}
+function main(argv, io) {
+  const allows = [];
+  const allowVarPrefixes = [];
+  const roots = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--allow" || arg === "--allow-var") {
+      const value = argv[i + 1];
+      i++;
+      if (value === void 0 || value === "" || value.startsWith("--"))
+        return usage(io, `${arg} needs a value`);
+      if (arg === "--allow-var") {
+        allowVarPrefixes.push(value);
+        continue;
+      }
+      const allow = parseAllow(value);
+      if (typeof allow === "string") return usage(io, allow);
+      allows.push(allow);
+    } else if (arg.startsWith("--")) {
+      return usage(io, `unknown option ${arg}`);
+    } else {
+      roots.push(arg);
+    }
+  }
+  if (roots.length === 0) return usage(io, "no path given");
+  const missing = DESIGN_CSS.filter(
+    (file) => !existsSync(join(io.designDir, file))
+  );
+  if (missing.length > 0) {
+    io.err(
+      `walkeros-design-check: ${missing.join(", ")} missing in ${io.designDir}; build @walkeros/explorer first`
+    );
+    return 2;
+  }
+  const designNames = collectDeclaredNames(
+    DESIGN_CSS.map(
+      (file) => readFileSync(join(io.designDir, file), "utf8")
+    ).join("\n")
+  );
+  const files = [];
+  for (const root of roots) {
+    const path = resolve(io.cwd, root);
+    if (!existsSync(path)) {
+      io.err(`walkeros-design-check: ${root} does not exist`);
+      return 2;
+    }
+    walk(path, files);
+  }
+  const sources = files.map((path) => ({
+    file: relative(io.cwd, path).split(sep).join("/"),
+    text: readFileSync(path, "utf8")
+  }));
+  const fileAllowed = (file) => allows.some(
+    (allow) => allow.rule === void 0 && allow.pattern.test(file)
+  );
+  const ruleAllowed = (finding) => allows.some(
+    (allow) => allow.rule === finding.rule && allow.pattern.test(finding.file)
+  );
+  const scanned = sources.filter((source) => !fileAllowed(source.file));
+  if (scanned.length === 0) {
+    io.err(
+      "walkeros-design-check: no file scanned; check the paths and --allow globs"
+    );
+    return 2;
+  }
+  const context = {
+    designNames,
+    declaredNames: collectDeclaredNames(
+      sources.map((source) => source.text).join("\n")
+    ),
+    allowVarPrefixes,
+    // A literal behind a local name: scanned files only, never a design name.
+    literalLengths: new Set(
+      scanned.flatMap((source) => [...localLiteralLengths(source.file, source.text)]).filter((name) => !designNames.has(name.replace(/^--/, "")))
+    )
+  };
+  const findings = scanned.flatMap((source) => scanFile(source.file, source.text, context)).filter((finding) => !ruleAllowed(finding));
+  for (const finding of findings) {
+    io.out(
+      `${finding.file}:${finding.line}:${finding.column} ${finding.rule} ${finding.match}`
+    );
+  }
+  io.err(
+    `walkeros-design-check: ${findings.length} finding(s) in ${scanned.length} file(s)`
+  );
+  return findings.length > 0 ? 1 : 0;
+}
+
+// src/design/check/bin.ts
+var write = (stream) => (line) => {
+  stream.write(`${line}
+`);
+};
+try {
+  process.exitCode = main(process.argv.slice(2), {
+    cwd: process.cwd(),
+    // dist/design: the bin ships beside tokens.css, tailwind.css and base.css.
+    designDir: dirname(fileURLToPath(import.meta.url)),
+    out: write(process.stdout),
+    err: write(process.stderr)
+  });
+} catch (error) {
+  process.stderr.write(
+    `walkeros-design-check: ${error instanceof Error ? error.message : String(error)}
+`
+  );
+  process.exitCode = 2;
+}