@luz-ds/check 0.0.0-stage → 0.1.0

package/dist/luz-check.js

@@ -0,0 +1,3013 @@
+#!/usr/bin/env node
+
+// packages/check/src/main.js
+import { readFileSync as readFileSync2 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/check/src/cli.js
+import { lstatSync as lstatSync2, readFileSync } from "node:fs";
+import { dirname as dirname2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/check/src/sanitize.js
+var UNREADABLE = "<an unreadable name>";
+var ECHO_NAME = /^[A-Za-z0-9_:.\-/]{1,64}$/;
+var UNSAFE = [
+  [0, 31],
+  [127, 159],
+  [173, 173],
+  [1536, 1541],
+  [1564, 1564],
+  [1757, 1757],
+  [1807, 1807],
+  [6158, 6158],
+  [8203, 8207],
+  [8232, 8238],
+  [8288, 8303],
+  [55296, 63743],
+  [65279, 65279],
+  [65529, 65531],
+  [65534, 65535],
+  [119155, 119162],
+  [917504, 921599],
+  [983040, 1114111]
+];
+function isUnsafe(code2) {
+  for (const [from, to] of UNSAFE) if (code2 >= from && code2 <= to) return true;
+  return false;
+}
+function echoName(value) {
+  return typeof value === "string" && ECHO_NAME.test(value) ? value : UNREADABLE;
+}
+function displayPath(path) {
+  let out = "";
+  for (const char of String(path)) {
+    const code2 = char.codePointAt(0);
+    out += isUnsafe(code2) || code2 === 92 ? `\\u{${code2.toString(16)}}` : char;
+  }
+  return out;
+}
+function cleanText(value, max = 80) {
+  const text = String(value);
+  const chars = [...text];
+  let out = "";
+  for (let i = 0; i < chars.length; i++) {
+    const code2 = chars[i].codePointAt(0);
+    if (code2 === 27) {
+      const next = chars[i + 1];
+      if (next === "[") {
+        i += 2;
+        while (i < chars.length && !(chars[i].codePointAt(0) >= 64 && chars[i].codePointAt(0) <= 126)) i++;
+      } else if (next === "]") {
+        i += 2;
+        while (i < chars.length && chars[i] !== "\x07" && !(chars[i] === "\x1B" && chars[i + 1] === "\\")) i++;
+        if (chars[i] === "\x1B") i++;
+      } else i += 1;
+      continue;
+    }
+    if (!isUnsafe(code2)) out += chars[i];
+  }
+  const kept = [...out];
+  if (kept.length <= max) return out;
+  return max > 1 ? `${kept.slice(0, max - 1).join("")}\u2026` : kept.slice(0, max).join("");
+}
+
+// packages/check/src/messages.js
+var MAX_MESSAGE = 120;
+var COLOUR = /^#[0-9a-fA-F]{6}$/;
+var MESSAGES = {
+  // ---- blocks ----
+  "parse/error": {
+    severity: "block",
+    template: "{kind} is cut short here; add the missing end of the comment, tag, string or brace"
+  },
+  "parse/error:template": {
+    severity: "warn",
+    template: "{kind} may be cut short here, or a template tag breaks it; add the missing end of the tag, comment or string"
+  },
+  "class/unknown": {
+    severity: "block",
+    template: ".{name} is not a LUZ class; the closest is .{closest}"
+  },
+  "class/unknown:none": {
+    severity: "block",
+    template: ".{name} is not a LUZ class; see classes.json of @luz-ds/{package}"
+  },
+  "class/unknown:newer": {
+    severity: "warn",
+    template: ".{name} is not in LUZ {known}, and the page loads {linked}; see classes.json of @luz-ds/{package}"
+  },
+  "element/unknown": {
+    severity: "block",
+    template: "<{tag}> is not a LUZ element; the closest is <{closest}>"
+  },
+  "element/unknown:none": {
+    severity: "block",
+    template: "<{tag}> is not a LUZ element; see custom-elements.json of @luz-ds/{package}"
+  },
+  "element/unknown-attribute": {
+    severity: "block",
+    template: "{attribute} is not an attribute of <{tag}>; the closest is {closest}"
+  },
+  "element/unknown-attribute:none": {
+    severity: "block",
+    template: "{attribute} is not an attribute of <{tag}>; see custom-elements.json for the ones it reads"
+  },
+  "load/tokens-missing": {
+    severity: "block",
+    template: "{package} is linked and @luz-ds/tokens is not; add @luz-ds/tokens before it"
+  },
+  "load/package-missing": {
+    severity: "block",
+    template: ".{name} is in @luz-ds/{package}, which this page does not load; add its stylesheet after core"
+  },
+  "load/package-missing:tag": {
+    severity: "block",
+    template: "<{tag}> is in @luz-ds/{package}, which this page does not load; add its stylesheet after core"
+  },
+  "load/layer-statement": {
+    severity: "block",
+    template: "<{tag}> declares the layers after the LUZ link; move it before the first LUZ stylesheet"
+  },
+  "misuse/host-element": {
+    severity: "block",
+    template: ".{name} is on <{tag}>; use {hosts}"
+  },
+  "misuse/modifier-alone": {
+    severity: "block",
+    template: ".{modifier} needs .{block} on the same element; add .{block}"
+  },
+  "theme/contrast": {
+    severity: "block",
+    template: "{mode}: {foreground} on {background} is {ratio}:1, needs {minimum}:1 ({kind}); change one of the two"
+  },
+  "theme/contrast:layers": {
+    severity: "block",
+    template: "{mode}: {foreground} on {background} is {ratio}:1, needs {minimum}:1; change one of the two"
+  },
+  "theme/unreadable": {
+    severity: "block",
+    template: "{token} is set to a colour the check cannot read; write the sRGB value as #rrggbb"
+  },
+  // ---- warnings ----
+  "load/order": {
+    severity: "warn",
+    template: "{first} is linked before {second}; move {second} before {first}"
+  },
+  "load/no-stylesheet": {
+    severity: "warn",
+    template: "{count} checked files load no LUZ stylesheet; add the LUZ links to the page or its layout"
+  },
+  "load/no-stylesheet:one": {
+    severity: "warn",
+    template: "{count} checked file loads no LUZ stylesheet; add the LUZ links to the page or its layout"
+  },
+  "class/unknown-in-css": {
+    severity: "warn",
+    template: ".{name} is not a LUZ class; the closest is .{closest}"
+  },
+  "class/unknown-in-css:none": {
+    severity: "warn",
+    template: ".{name} is not a LUZ class; see classes.json of @luz-ds/{package}"
+  },
+  "class/reserved-prefix": {
+    severity: "warn",
+    template: ".{name} starts with luz-, the prefix LUZ keeps for itself; change it to your own prefix"
+  },
+  "misuse/state-class": {
+    severity: "warn",
+    template: ".{name} is a state that LUZ's script sets; remove it from the markup"
+  },
+  "misuse/part-orphan": {
+    severity: "warn",
+    template: ".{name} is a part of .{block}; add an element with .{block} around it"
+  },
+  "a11y/role-on-generic": {
+    severity: "warn",
+    template: "{role} is a role set on <{tag}>; use <{element}> instead"
+  },
+  "a11y/role-on-generic:onclick": {
+    severity: "warn",
+    template: "{attribute} on <{tag}> does not work from the keyboard; use <button> instead"
+  },
+  "a11y/link-no-href": {
+    severity: "warn",
+    template: "<{tag}> has .{name} and no href; add an href, or use <button> for an action"
+  },
+  "attr/unknown-hook": {
+    severity: "warn",
+    template: "{attribute} is not a data-luz-* attribute that LUZ reads; remove it or check the spelling"
+  },
+  "css/literal-colour": {
+    severity: "warn",
+    template: "{property} is set to {value}; use a token, such as var({token})"
+  },
+  "css/literal-colour:none": {
+    severity: "warn",
+    template: "{property} is set to a literal colour; use a token, such as var({token})"
+  },
+  "css/literal-size": {
+    severity: "warn",
+    template: "{property} is {value}; use a --luz-space-*, --luz-text-* or --luz-radius-* token"
+  },
+  "css/knob-in-px": {
+    severity: "warn",
+    template: "{property} is in px, which ignores the browser's text size; use rem"
+  },
+  "css/important": {
+    severity: "warn",
+    template: "{property} is set with !important; remove it, a rule outside a layer already wins"
+  },
+  "css/private-token": {
+    severity: "warn",
+    template: "{token} belongs to one component; use a token that LUZ sets on :root"
+  },
+  "css/unknown-token": {
+    severity: "warn",
+    template: "{token} is not a LUZ token; the closest is {closest}"
+  },
+  "css/unknown-token:none": {
+    severity: "warn",
+    template: "{token} is not a LUZ token; see the token pages of the docs"
+  },
+  "file/skipped": {
+    severity: "warn",
+    template: "{reason} kept this path from being read; see luz-check --help for the limits"
+  },
+  "theme/advisory": {
+    severity: "warn",
+    template: "{source} order is used for the theme files; use --theme to set the order"
+  },
+  "theme/advisory:unplaced": {
+    severity: "warn",
+    template: "{token} is set where no colour mode can place it; move it to :root or a [data-theme] rule"
+  },
+  "theme/advisory:wide": {
+    severity: "warn",
+    template: "{token} is a wide-gamut colour in @supports, which is not measured; see the contrast docs for what is read"
+  },
+  "theme/advisory:limit": {
+    severity: "warn",
+    template: "{count} custom themes past the first {limit} are not measured; remove the ones you do not ship"
+  }
+};
+var SITE_URL = "https://nandovejer.github.io/luz/";
+var AI = "docs/get-started/ai/#rules";
+var READ = "docs/get-started/how-to-read/";
+var DOCS = {
+  "parse/error": AI,
+  "class/unknown": `${READ}#classes`,
+  "class/unknown-in-css": `${READ}#classes`,
+  "class/reserved-prefix": `${READ}#classes`,
+  "element/unknown": `${READ}#elements`,
+  "element/unknown-attribute": `${READ}#attributes`,
+  "attr/unknown-hook": `${READ}#attributes`,
+  "load/tokens-missing": "docs/get-started/#which-level",
+  "load/package-missing": "docs/get-started/#which-level",
+  "load/no-stylesheet": "docs/get-started/#which-level",
+  "load/order": "docs/get-started/layers/#order",
+  "load/layer-statement": "docs/get-started/layers/#order",
+  "misuse/host-element": `${READ}#classes`,
+  "misuse/modifier-alone": `${READ}#classes`,
+  "misuse/state-class": `${READ}#public`,
+  "misuse/part-orphan": `${READ}#classes`,
+  "a11y/role-on-generic": AI,
+  "a11y/link-no-href": AI,
+  "css/literal-colour": `${READ}#tokens`,
+  "css/literal-size": `${READ}#tokens`,
+  "css/knob-in-px": `${READ}#tokens`,
+  "css/important": "docs/get-started/layers/#unlayered",
+  "css/private-token": `${READ}#public`,
+  "css/unknown-token": `${READ}#tokens`,
+  "file/skipped": AI,
+  "theme/contrast": "docs/tokens/contrast/#checks",
+  "theme/unreadable": "docs/tokens/contrast/#reads",
+  "theme/advisory": "docs/tokens/contrast/#reads"
+};
+function docsUrl(rule) {
+  const base = String(rule).split(":")[0];
+  if (!Object.hasOwn(DOCS, base)) throw new Error(`no docs for the rule ${echoName(base)}`);
+  return `${SITE_URL}${DOCS[base]}`;
+}
+var SPLIT = /* @__PURE__ */ new Map();
+function echoed(value) {
+  if (Array.isArray(value)) return value.map((item) => `<${echoName(item)}>`).join(", ");
+  const text = String(value);
+  if (COLOUR.test(text)) return text.toLowerCase();
+  return echoName(text);
+}
+function fit(values, room) {
+  let limit = Math.max(...values.map((value) => value.length));
+  while (limit > 2 && values.reduce((sum, value) => sum + Math.min(value.length, limit), 0) > room) limit--;
+  return values.map((value) => value.length > limit ? `${value.slice(0, limit - 1)}\u2026` : value);
+}
+function message(key, vars) {
+  if (typeof key !== "string" || !Object.hasOwn(MESSAGES, key)) throw new Error(`no message for the key ${echoName(key)}`);
+  const given = vars && typeof vars === "object" ? vars : {};
+  const one = `${key}:one`;
+  const chosen = given.count === "1" && Object.hasOwn(MESSAGES, one) ? one : key;
+  let known = SPLIT.get(chosen);
+  if (known === void 0) {
+    const parts2 = MESSAGES[chosen].template.split(/\{([A-Za-z][A-Za-z0-9]*)\}/);
+    known = { parts: parts2, fixed: parts2.reduce((sum, text, i) => i % 2 === 0 ? sum + text.length : sum, 0) };
+    SPLIT.set(chosen, known);
+  }
+  const { parts, fixed } = known;
+  let values = [];
+  for (let i = 1; i < parts.length; i += 2) {
+    const name = parts[i];
+    if (!Object.hasOwn(given, name) || given[name] === void 0 || given[name] === null) throw new Error(`the message ${key} needs the variable ${name}`);
+    values.push(echoed(given[name]));
+  }
+  if (fixed + values.reduce((sum, value) => sum + value.length, 0) > MAX_MESSAGE) values = fit(values, MAX_MESSAGE - fixed);
+  let out = "";
+  for (let i = 0; i < parts.length; i++) out += i % 2 === 0 ? parts[i] : values[(i - 1) / 2];
+  return out.length > MAX_MESSAGE ? `${out.slice(0, MAX_MESSAGE - 1)}\u2026` : out;
+}
+
+// packages/check/src/config.js
+var MAX_CONFIG_BYTES = 65536;
+var MAX_LIST = 1e3;
+var KEYS = ["ignore", "rules", "themes", "strict"];
+var ALWAYS_ON = /* @__PURE__ */ new Set(["file/skipped"]);
+var OFFABLE = new Set(
+  Object.entries(MESSAGES).filter(([key, entry]) => entry.severity === "warn" && !key.includes(":") && !ALWAYS_ON.has(key)).map(([key]) => key)
+);
+var KNOWN = new Set(Object.keys(MESSAGES).map((key) => key.split(":")[0]));
+var ConfigError = class extends Error {
+  constructor(file, message2) {
+    super(`${displayPath(file)}: ${message2}`);
+    this.name = "ConfigError";
+  }
+};
+var isList = (value) => Array.isArray(value) && value.length <= MAX_LIST && value.every((item) => typeof item === "string");
+function parseConfig(text, file = "luz-check.json") {
+  const fail = (message2) => {
+    throw new ConfigError(file, message2);
+  };
+  if (typeof text !== "string") fail("is not text");
+  if (Buffer.byteLength(text, "utf-8") > MAX_CONFIG_BYTES) fail("is larger than 64 kB");
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return fail("is not valid JSON");
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return fail("must be a JSON object");
+  const result = { ignore: [], rules: /* @__PURE__ */ Object.create(null), themes: [], strict: false };
+  for (const key of Object.keys(data)) {
+    if (!KEYS.includes(key)) fail(`has a key luz-check does not know: ${echoName(key)}`);
+  }
+  if (Object.hasOwn(data, "ignore")) {
+    if (!isList(data.ignore)) fail(`"ignore" must be a list of patterns`);
+    result.ignore = data.ignore.slice();
+  }
+  if (Object.hasOwn(data, "themes")) {
+    if (!isList(data.themes)) fail(`"themes" must be a list of files`);
+    result.themes = data.themes.slice();
+  }
+  if (Object.hasOwn(data, "strict")) {
+    if (typeof data.strict !== "boolean") fail('"strict" must be true or false');
+    result.strict = data.strict;
+  }
+  if (Object.hasOwn(data, "rules")) {
+    const { rules } = data;
+    if (rules === null || typeof rules !== "object" || Array.isArray(rules)) fail('"rules" must be an object of rule ids');
+    for (const id of Object.keys(rules)) {
+      const shown2 = echoName(id);
+      if (!KNOWN.has(id)) fail(`"rules" names a rule that does not exist: ${shown2}`);
+      if (!OFFABLE.has(id)) fail(`"rules" cannot switch off ${shown2}; a blocking rule is silenced with "ignore" only`);
+      if (rules[id] !== "off") fail(`"rules" may set ${shown2} to "off" and nothing else`);
+      result.rules[id] = "off";
+    }
+  }
+  return result;
+}
+
+// packages/check/src/html.js
+var VOID = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+var RAW_TEXT_END = {
+  script: /<\/script/gi,
+  style: /<\/style/gi,
+  textarea: /<\/textarea/gi,
+  title: /<\/title/gi
+};
+var FOREIGN = /* @__PURE__ */ new Set(["svg", "math"]);
+var MAX_DEPTH = 256;
+var ATTR = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0" };
+var NO_PROBLEMS = Object.freeze([]);
+function decodeEntities(text) {
+  return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (whole, ref) => {
+    if (ref[0] === "#") {
+      const code2 = ref[1] === "x" || ref[1] === "X" ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
+      return Number.isFinite(code2) && code2 <= 1114111 ? String.fromCodePoint(code2) : whole;
+    }
+    return ENTITIES[ref.toLowerCase()] ?? whole;
+  });
+}
+var HtmlError = class extends Error {
+  constructor(file, line, message2) {
+    super(`${file}:${line}: ${message2}`);
+    this.name = "HtmlError";
+    this.file = file;
+    this.line = line;
+  }
+};
+function lineStarts(html) {
+  const starts = [0];
+  for (let i = html.indexOf("\n"); i !== -1; i = html.indexOf("\n", i + 1)) starts.push(i + 1);
+  return starts;
+}
+function lineAt(starts, index) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= index) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo + 1;
+}
+function* tokenize(html, file, lenient, detail) {
+  const starts = lineStarts(html);
+  const length = html.length;
+  let i = 0;
+  const problem = (index, message2) => {
+    const line = lineAt(starts, index);
+    if (!lenient) throw new HtmlError(file, line, message2);
+    return { type: "error", line, column: index - starts[line - 1] + 1, message: message2 };
+  };
+  while (i < length) {
+    const lt = html.indexOf("<", i);
+    if (lt === -1) return;
+    if (html.startsWith("<!--", lt)) {
+      const close = html.indexOf("-->", lt + 4);
+      if (close === -1) {
+        yield problem(lt, "comment is never closed");
+        return;
+      }
+      i = close + 3;
+      continue;
+    }
+    if (html[lt + 1] === "!" || html[lt + 1] === "?") {
+      const close = html.indexOf(">", lt);
+      i = close === -1 ? length : close + 1;
+      continue;
+    }
+    const line = lineAt(starts, lt);
+    const column = lt - starts[line - 1] + 1;
+    const endTag = /^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>/.exec(html.slice(lt, lt + 80));
+    if (endTag) {
+      const end = lt + endTag[0].length;
+      yield { type: "end", name: endTag[1].toLowerCase(), attrs: /* @__PURE__ */ new Map(), selfClosing: false, line, column, index: lt, end };
+      i = end;
+      continue;
+    }
+    const open = /^<([a-zA-Z][a-zA-Z0-9-]*)/.exec(html.slice(lt, lt + 80));
+    if (!open) {
+      i = lt + 1;
+      continue;
+    }
+    const nameEnd = lt + open[0].length;
+    let j = nameEnd;
+    let quote = null;
+    for (; j < length; j++) {
+      const c = html[j];
+      if (quote) {
+        if (c === quote) quote = null;
+      } else if (c === '"' || c === "'") quote = c;
+      else if (c === ">") break;
+    }
+    if (j >= length) {
+      yield problem(lt, `<${open[1]}> start tag is never closed with ">"`);
+      return;
+    }
+    const inside2 = html.slice(nameEnd, j);
+    const selfClosing = /\/\s*$/.test(inside2);
+    const attrs = /* @__PURE__ */ new Map();
+    let problems = NO_PROBLEMS;
+    for (const m of inside2.replace(/\/\s*$/, "").matchAll(ATTR)) {
+      const attrName = m[1].toLowerCase();
+      const at2 = detail || lenient ? nameEnd + m.index : 0;
+      if (attrs.has(attrName)) {
+        if (!lenient) throw new HtmlError(file, line, `<${open[1]}> has the attribute "${attrName}" twice`);
+        const dupLine = lineAt(starts, at2);
+        if (problems === NO_PROBLEMS) problems = [];
+        problems.push({ code: "duplicate-attribute", name: attrName, line: dupLine, column: at2 - starts[dupLine - 1] + 1 });
+        continue;
+      }
+      const value = decodeEntities(m[2] ?? m[3] ?? m[4] ?? "");
+      if (detail) {
+        const attrLine = lineAt(starts, at2);
+        attrs.set(attrName, { value, line: attrLine, column: at2 - starts[attrLine - 1] + 1 });
+      } else attrs.set(attrName, value);
+    }
+    const name = open[1].toLowerCase();
+    const token = { type: "start", name, written: open[1], attrs, selfClosing, line, column, index: lt, end: j + 1 };
+    if (lenient) token.problems = problems;
+    i = j + 1;
+    if (RAW_TEXT_END[name] && !selfClosing) {
+      const re = RAW_TEXT_END[name];
+      re.lastIndex = i;
+      const found = re.exec(html);
+      if (detail) token.text = html.slice(i, found ? found.index : length);
+      yield token;
+      if (!found) {
+        yield problem(lt, `<${name}> is never closed`);
+        return;
+      }
+      i = found.index;
+      continue;
+    }
+    yield token;
+  }
+}
+function* scan(html, file = "<html>") {
+  const stack = [];
+  const owners = [];
+  let foreign = 0;
+  for (const token of tokenize(html, file, true, true)) {
+    if (token.type === "error") {
+      yield { type: "error", line: token.line, column: token.column, message: token.message };
+      return;
+    }
+    const { name } = token;
+    if (token.type === "start") {
+      const parent = owners.length > 0 ? owners[owners.length - 1] : null;
+      const record = {
+        type: "element",
+        name,
+        written: token.written,
+        attrs: token.attrs,
+        parentChain: stack.slice(),
+        parent,
+        inert: token.attrs.has("inert") || parent !== null && parent.inert,
+        selfClosing: token.selfClosing,
+        line: token.line,
+        column: token.column,
+        problems: token.problems
+      };
+      if (token.text !== void 0) record.text = token.text;
+      yield record;
+      if (VOID.has(name) || stack.length >= MAX_DEPTH) continue;
+      if (token.selfClosing && (foreign > 0 || FOREIGN.has(name))) continue;
+      stack.push(name);
+      owners.push(record);
+      if (FOREIGN.has(name)) foreign++;
+    } else {
+      const at2 = stack.lastIndexOf(name);
+      if (at2 === -1) continue;
+      owners.length = at2;
+      while (stack.length > at2) if (FOREIGN.has(stack.pop())) foreign--;
+    }
+  }
+}
+
+// packages/check/src/css.js
+var MAX_DEPTH2 = 64;
+var MAX_FINDINGS = 100;
+var CONDITIONAL = /* @__PURE__ */ new Set(["media", "supports", "container", "scope", "starting-style", "document", "layer"]);
+var STATEMENTS = /* @__PURE__ */ new Set(["import", "charset", "namespace", "layer"]);
+var DECLARATIONS = /* @__PURE__ */ new Set(["font-face", "property", "counter-style", "page", "font-feature-values", "font-palette-values", "view-transition", "position-try", "color-profile"]);
+var MARGIN_BOX = /^(?:top|bottom|left|right)-/;
+var TRANSPARENT = /* @__PURE__ */ new Set(["is", "where", "matches", "any"]);
+var CssError = class extends Error {
+  constructor(file, line, column, message2) {
+    super(`${file}:${line}:${column}: ${message2}`);
+    this.name = "CssError";
+    this.file = file;
+    this.line = line;
+    this.column = column;
+  }
+};
+var Halt = class extends Error {
+};
+var TAB = 9;
+var LF = 10;
+var FF = 12;
+var CR = 13;
+var SPACE = 32;
+var QUOTE2 = 34;
+var QUOTE1 = 39;
+var OPEN_PAREN = 40;
+var CLOSE_PAREN = 41;
+var STAR = 42;
+var PLUS = 43;
+var COMMA = 44;
+var MINUS = 45;
+var DOT = 46;
+var SLASH = 47;
+var COLON = 58;
+var SEMI = 59;
+var GT = 62;
+var AT = 64;
+var OPEN_BRACKET = 91;
+var BACKSLASH = 92;
+var CLOSE_BRACKET = 93;
+var UNDERSCORE = 95;
+var OPEN_BRACE = 123;
+var PIPE = 124;
+var CLOSE_BRACE = 125;
+var TILDE = 126;
+var AMP = 38;
+var HASH = 35;
+var isDigit = (c) => c >= 48 && c <= 57;
+var isHex = (c) => isDigit(c) || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+var isIdent = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90 || isDigit(c) || c === MINUS || c === UNDERSCORE || c >= 128;
+var isSpace = (c) => c === SPACE || c === TAB || c === LF || c === CR || c === FF;
+var UNESCAPE = /\\([0-9a-fA-F]{1,6})(?:\r\n|[ \t\n\r\f])?|\\([\s\S])/g;
+function unescapeCss(text) {
+  return text.replace(UNESCAPE, (_, hex, other) => {
+    if (other !== void 0) return other;
+    const code2 = parseInt(hex, 16);
+    return code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343 ? "\uFFFD" : String.fromCodePoint(code2);
+  });
+}
+function readCss(text, file = "<css>", { strict = false } = {}) {
+  const starts = lineStarts(text);
+  const length = text.length;
+  const classes = /* @__PURE__ */ new Map();
+  const properties = /* @__PURE__ */ new Map();
+  const findings = [];
+  const declarations = [];
+  const HALT = new Halt();
+  const DECLS = { kind: "decls", layer: null, sel: null };
+  let pos = 0;
+  let depth = 0;
+  let eofReported = false;
+  function report(index, message2) {
+    const line = lineAt(starts, index);
+    const column = index - starts[line - 1] + 1;
+    if (strict) throw new CssError(file, line, column, message2);
+    findings.push({ rule: "parse/error", line, column, message: message2 });
+    if (findings.length >= MAX_FINDINGS) throw HALT;
+  }
+  function fatal(index, message2) {
+    report(index, message2);
+    throw HALT;
+  }
+  function skipComment(p) {
+    const close = text.indexOf("*/", p + 2);
+    if (close === -1) {
+      report(p, "comment is never closed");
+      return length;
+    }
+    return close + 2;
+  }
+  function skipString(p) {
+    const quote = text.charCodeAt(p);
+    for (let i = p + 1; i < length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === BACKSLASH) {
+        if (text.charCodeAt(i + 1) === CR && text.charCodeAt(i + 2) === LF) i += 2;
+        else i++;
+      } else if (c === quote) return i + 1;
+      else if (c === LF || c === CR || c === FF) {
+        report(p, "string is never closed");
+        return i;
+      }
+    }
+    report(p, "string is never closed");
+    return length;
+  }
+  function identEnd(p) {
+    let i = p;
+    while (i < length) {
+      const c = text.charCodeAt(i);
+      if (c === BACKSLASH) {
+        const next = text.charCodeAt(i + 1);
+        if (Number.isNaN(next) || next === LF || next === CR || next === FF) break;
+        i++;
+        if (isHex(next)) {
+          let n = 1;
+          while (n < 6 && isHex(text.charCodeAt(i + 1))) {
+            i++;
+            n++;
+          }
+          i++;
+          if (text.charCodeAt(i) === CR && text.charCodeAt(i + 1) === LF) i++;
+          if (isSpace(text.charCodeAt(i))) i++;
+        } else i++;
+      } else if (isIdent(c)) i++;
+      else break;
+    }
+    return i;
+  }
+  const identText = (a, b) => {
+    const raw = text.slice(a, b);
+    return raw.includes("\\") ? unescapeCss(raw) : raw;
+  };
+  function isRawUrl(p) {
+    if (p < 3) return false;
+    if ((text.charCodeAt(p - 1) | 32) !== 108 || (text.charCodeAt(p - 2) | 32) !== 114 || (text.charCodeAt(p - 3) | 32) !== 117) return false;
+    if (p > 3 && isIdent(text.charCodeAt(p - 4))) return false;
+    let i = p + 1;
+    while (i < length && isSpace(text.charCodeAt(i))) i++;
+    const c = text.charCodeAt(i);
+    return c !== QUOTE1 && c !== QUOTE2;
+  }
+  function skipRawUrl(p) {
+    for (let i = p + 1; i < length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === BACKSLASH) i++;
+      else if (c === CLOSE_PAREN) return i + 1;
+    }
+    report(p, "parenthesis is never closed");
+    return length;
+  }
+  function scanUntil(from, braces) {
+    const closers = [];
+    const opened = [];
+    const open = (closer, at2) => {
+      if (closers.length >= MAX_DEPTH2) fatal(at2, "brackets are nested too deep");
+      closers.push(closer);
+      opened.push(at2);
+    };
+    const unclosed = () => {
+      const closer = closers[closers.length - 1];
+      const what = closer === CLOSE_PAREN ? "parenthesis" : closer === CLOSE_BRACKET ? "bracket" : "brace";
+      report(opened[opened.length - 1], `${what} is never closed`);
+      closers.length = 0;
+      opened.length = 0;
+    };
+    let p = from;
+    while (p < length) {
+      const c = text.charCodeAt(p);
+      switch (c) {
+        case SLASH:
+          p = text.charCodeAt(p + 1) === STAR ? skipComment(p) : p + 1;
+          break;
+        case QUOTE1:
+        case QUOTE2:
+          p = skipString(p);
+          break;
+        case BACKSLASH:
+          p += 2;
+          break;
+        case OPEN_PAREN:
+          if (isRawUrl(p)) p = skipRawUrl(p);
+          else {
+            open(CLOSE_PAREN, p);
+            p++;
+          }
+          break;
+        case OPEN_BRACKET:
+          open(CLOSE_BRACKET, p);
+          p++;
+          break;
+        case CLOSE_PAREN:
+        case CLOSE_BRACKET:
+          if (closers.length && closers[closers.length - 1] === c) {
+            closers.pop();
+            opened.pop();
+          } else report(p, c === CLOSE_PAREN ? "unmatched closing parenthesis" : "unmatched closing bracket");
+          p++;
+          break;
+        case OPEN_BRACE:
+          if (braces) {
+            open(CLOSE_BRACE, p);
+            p++;
+            break;
+          }
+          if (closers.length) unclosed();
+          pos = p;
+          return c;
+        case CLOSE_BRACE:
+          if (braces && closers.length && closers[closers.length - 1] === CLOSE_BRACE) {
+            closers.pop();
+            opened.pop();
+            p++;
+            break;
+          }
+          if (closers.length) unclosed();
+          pos = p;
+          return c;
+        case SEMI:
+          if (closers.length === 0) {
+            pos = p;
+            return c;
+          }
+          p++;
+          break;
+        default:
+          p++;
+      }
+    }
+    if (closers.length) unclosed();
+    pos = length;
+    return -1;
+  }
+  function readList(from, to, inParen) {
+    const list = [];
+    let p = from;
+    for (; ; ) {
+      const complex = readComplex(p, to, inParen);
+      list.push(complex.value);
+      p = complex.next;
+      if (p < to && text.charCodeAt(p) === COMMA) {
+        p++;
+        continue;
+      }
+      return { list, next: p };
+    }
+  }
+  function readComplex(from, to, inParen) {
+    const items = [];
+    let compounds = 0;
+    let inCompound = false;
+    let amp = false;
+    let mark = false;
+    let plain = true;
+    let p = from;
+    while (p < to) {
+      const c = text.charCodeAt(p);
+      if (c === COMMA) break;
+      if (c === CLOSE_PAREN) {
+        if (inParen) break;
+        p++;
+        continue;
+      }
+      if (isSpace(c)) {
+        inCompound = false;
+        p++;
+        continue;
+      }
+      if (c === GT || c === PLUS || c === TILDE) {
+        inCompound = false;
+        p++;
+        continue;
+      }
+      if (c === PIPE && text.charCodeAt(p + 1) === PIPE) {
+        inCompound = false;
+        p += 2;
+        continue;
+      }
+      if (c === SLASH && text.charCodeAt(p + 1) === STAR) {
+        const close = text.indexOf("*/", p + 2);
+        p = close === -1 || close + 2 > to ? to : close + 2;
+        continue;
+      }
+      if (!inCompound) {
+        compounds++;
+        inCompound = true;
+      }
+      if (c === DOT) {
+        const end = identEnd(p + 1);
+        if (end > p + 1) items.push({ name: identText(p + 1, end), index: p, ok: true });
+        plain = false;
+        p = Math.max(end, p + 1);
+      } else if (c === HASH) {
+        plain = false;
+        p = Math.max(identEnd(p + 1), p + 1);
+      } else if (c === OPEN_BRACKET) {
+        const end = identEnd(p + 1);
+        if (text.startsWith("data-theme", p + 1) && end - (p + 1) >= 10) mark = true;
+        p = skipBracket(p, to);
+      } else if (c === COLON) {
+        p++;
+        if (text.charCodeAt(p) === COLON) p++;
+        const end = identEnd(p);
+        const name = text.slice(p, end).toLowerCase().replace(/^-(?:webkit|moz)-/, "");
+        p = Math.max(end, p);
+        if (text.charCodeAt(p) === OPEN_PAREN && p < to) {
+          const inner = readList(p + 1, to, true);
+          p = inner.next;
+          if (text.charCodeAt(p) === CLOSE_PAREN) p++;
+          const through = TRANSPARENT.has(name);
+          for (const complex of inner.list) {
+            for (const item of complex.items) items.push({ name: item.name, index: item.index, ok: through && item.ok && complex.compounds <= 1 });
+          }
+        } else if (name === "root") mark = true;
+      } else if (c === OPEN_PAREN) {
+        const inner = readList(p + 1, to, true);
+        p = inner.next;
+        if (text.charCodeAt(p) === CLOSE_PAREN) p++;
+        for (const complex of inner.list) for (const item of complex.items) items.push({ name: item.name, index: item.index, ok: false });
+      } else if (c === AMP) {
+        amp = true;
+        p++;
+      } else if (c === QUOTE1 || c === QUOTE2) {
+        p = skipQuoted(p, to);
+      } else if (isIdent(c) || c === BACKSLASH) {
+        const end = identEnd(p);
+        if (end > p && text.slice(p, end).toLowerCase() === "html") mark = true;
+        p = Math.max(end, p + 1);
+      } else p++;
+    }
+    return { value: { compounds, amp, root: mark && plain && compounds === 1, items }, next: p };
+  }
+  function skipBracket(p, to) {
+    for (let i = p + 1; i < to; i++) {
+      const c = text.charCodeAt(i);
+      if (c === BACKSLASH) i++;
+      else if (c === QUOTE1 || c === QUOTE2) i = skipQuoted(i, to) - 1;
+      else if (c === CLOSE_BRACKET) return i + 1;
+    }
+    return to;
+  }
+  function skipQuoted(p, to) {
+    const quote = text.charCodeAt(p);
+    for (let i = p + 1; i < to; i++) {
+      const c = text.charCodeAt(i);
+      if (c === BACKSLASH) i++;
+      else if (c === quote) return i + 1;
+    }
+    return to;
+  }
+  function addClass(name, index, defined, layer) {
+    const known = classes.get(name);
+    if (known === void 0) {
+      const line = lineAt(starts, index);
+      classes.set(name, { name, defined, layer, line, column: index - starts[line - 1] + 1 });
+    } else if (defined && !known.defined) {
+      known.defined = true;
+      known.layer = layer;
+    }
+  }
+  function addProperty(name, index, ctx) {
+    const scope = ctx.sel !== null && ctx.sel.root ? "root" : "component";
+    const known = properties.get(name);
+    if (known === void 0 || scope === "root" && known.scope !== "root") {
+      const line = lineAt(starts, index);
+      properties.set(name, { name, scope, layer: ctx.layer, line, column: index - starts[line - 1] + 1 });
+    }
+  }
+  function styleRule(ctx, from, to) {
+    const { list } = readList(from, to, false);
+    const nested = ctx.kind === "style";
+    let single = false;
+    let root = false;
+    for (const complex of list) {
+      const own = nested ? complex.compounds === 1 && complex.amp && ctx.sel.single : complex.compounds === 1;
+      if (own) single = true;
+      if (complex.root || nested && complex.amp && complex.compounds === 1 && ctx.sel.root) root = true;
+      for (const item of complex.items) addClass(item.name, item.index, own && item.ok, ctx.layer);
+    }
+    return { kind: "style", layer: ctx.layer, sel: { single, root } };
+  }
+  function skipTrivia() {
+    while (pos < length) {
+      const c = text.charCodeAt(pos);
+      if (isSpace(c) || c === 65279) pos++;
+      else if (c === SLASH && text.charCodeAt(pos + 1) === STAR) pos = skipComment(pos);
+      else break;
+    }
+  }
+  function enterBlock(braceAt, ctx) {
+    if (depth >= MAX_DEPTH2) fatal(braceAt, "blocks are nested too deep");
+    depth++;
+    const closed = readItems(ctx);
+    depth--;
+    if (!closed && !eofReported) {
+      eofReported = true;
+      report(braceAt, "block is never closed");
+    }
+  }
+  function startsCustomProperty() {
+    if (text.charCodeAt(pos) !== MINUS || text.charCodeAt(pos + 1) !== MINUS) return false;
+    let i = identEnd(pos);
+    while (i < length && isSpace(text.charCodeAt(i))) i++;
+    return text.charCodeAt(i) === COLON;
+  }
+  function declare(from, to) {
+    for (let i = from; i < to; i++) {
+      if (text.charCodeAt(i) === COLON) {
+        declarations.push(from, i, to);
+        return;
+      }
+    }
+  }
+  function customProperty(ctx) {
+    const start = pos;
+    const end = identEnd(pos);
+    addProperty(identText(start, end), start, ctx);
+    pos = end;
+    const term = scanUntil(end, true);
+    declare(start, pos);
+    if (term === SEMI) pos++;
+  }
+  function atRule(ctx) {
+    const at2 = pos;
+    const nameEnd = identEnd(pos + 1);
+    const name = text.slice(pos + 1, nameEnd).toLowerCase().replace(/^-[a-z]+-/, "");
+    const preludeStart = nameEnd;
+    const term = scanUntil(nameEnd, false);
+    if (term !== OPEN_BRACE) {
+      if (term === SEMI) pos++;
+      if (ctx.kind !== "decls" && !STATEMENTS.has(name) && !CONDITIONAL.has(name) && !DECLARATIONS.has(name)) report(at2, "unknown at-rule");
+      return;
+    }
+    const braceAt = pos;
+    pos++;
+    let child = DECLS;
+    if (ctx.kind === "decls") child = DECLS;
+    else if (name === "layer" || CONDITIONAL.has(name)) {
+      const kind = ctx.kind === "style" ? "style" : "rules";
+      let layer = ctx.layer;
+      if (name === "layer") {
+        const written = text.slice(preludeStart, braceAt).replace(/\/\*[\s\S]*?\*\//g, "").trim();
+        if (/^[\w.-]+$/.test(written)) layer = ctx.layer ? `${ctx.layer}.${written}` : written;
+      } else if (name === "scope") {
+        for (const complex of readList(preludeStart, braceAt, false).list) for (const item of complex.items) addClass(item.name, item.index, false, ctx.layer);
+      }
+      child = { kind, layer, sel: ctx.sel };
+    } else if (name === "keyframes") child = { kind: "keyframes", layer: ctx.layer, sel: null };
+    else if (!DECLARATIONS.has(name) && !MARGIN_BOX.test(name)) report(at2, "unknown at-rule");
+    enterBlock(braceAt, child);
+  }
+  function statement(ctx) {
+    const start = pos;
+    const term = scanUntil(pos, false);
+    if (term !== OPEN_BRACE) {
+      if (ctx.kind !== "rules") declare(start, pos);
+      if (term === SEMI) pos++;
+      return;
+    }
+    const braceAt = pos;
+    pos++;
+    enterBlock(braceAt, ctx.kind === "rules" || ctx.kind === "style" ? styleRule(ctx, start, braceAt) : DECLS);
+  }
+  function readItems(ctx) {
+    for (; ; ) {
+      skipTrivia();
+      if (pos >= length) return false;
+      const c = text.charCodeAt(pos);
+      if (c === CLOSE_BRACE) {
+        pos++;
+        if (depth === 0) {
+          report(pos - 1, "unmatched closing brace");
+          continue;
+        }
+        return true;
+      }
+      if (c === SEMI) pos++;
+      else if (c === AT) atRule(ctx);
+      else if (ctx.kind === "style" && startsCustomProperty()) customProperty(ctx);
+      else statement(ctx);
+    }
+  }
+  try {
+    readItems({ kind: "rules", layer: null, sel: null });
+  } catch (error) {
+    if (error !== HALT) throw error;
+  }
+  return { classes: [...classes.values()], properties: [...properties.values()], declarations, findings };
+}
+
+// packages/check/src/manifests.js
+import { join, dirname } from "node:path";
+
+// packages/check/src/walk.js
+import { closeSync, constants, fstatSync, lstatSync, openSync, opendirSync, readSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+var MIB = 1024 * 1024;
+var LIMITS = Object.freeze({ fileBytes: MIB, totalBytes: 128 * MIB, entries: 5e3, depth: 64 });
+var SKIP_REASONS = Object.freeze(["symlink", "not-a-file", "too-large", "unreadable", "read-limit", "too-many-files", "too-deep"]);
+var DEFAULT_EXT = [
+  [".html", "html"],
+  [".htm", "html"],
+  [".css", "css"]
+];
+var NEVER_ENTERED = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var CHUNK = 64 * 1024;
+var byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function matchSegment(pattern, text) {
+  if (!pattern.includes("*") && !pattern.includes("?")) return pattern === text;
+  let p = 0;
+  let t = 0;
+  let star = -1;
+  let mark = 0;
+  while (t < text.length) {
+    if (p < pattern.length && pattern[p] === "*") {
+      star = p++;
+      mark = t;
+    } else if (p < pattern.length && (pattern[p] === "?" || pattern[p] === text[t])) {
+      p++;
+      t++;
+    } else if (star !== -1) {
+      p = star + 1;
+      t = ++mark;
+    } else return false;
+  }
+  while (p < pattern.length && pattern[p] === "*") p++;
+  return p === pattern.length;
+}
+var segmentsOf = (text) => text.split("/").filter((segment, i, all) => segment !== "" || i === all.length - 1);
+var compile = (pattern) => segmentsOf(pattern).map((segment) => segment === "**" ? null : segment);
+function matchSegments(pattern, parts) {
+  const cols = parts.length;
+  let next = new Array(cols + 1).fill(false);
+  next[cols] = true;
+  for (let i = pattern.length - 1; i >= 0; i--) {
+    const row = new Array(cols + 1).fill(false);
+    if (pattern[i] === null) {
+      row[cols] = next[cols];
+      for (let j = cols - 1; j >= 0; j--) row[j] = next[j] || row[j + 1];
+    } else {
+      for (let j = cols - 1; j >= 0; j--) row[j] = next[j + 1] && matchSegment(pattern[i], parts[j]);
+    }
+    next = row;
+  }
+  return next[0];
+}
+var hasWildcard = (text) => text.includes("*") || text.includes("?");
+function readLimited(absolute, max) {
+  let fd = null;
+  try {
+    fd = openSync(absolute, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    if (!fstatSync(fd).isFile()) return { reason: "not-a-file" };
+    const scratch = Buffer.allocUnsafe(CHUNK);
+    const chunks = [];
+    let length = 0;
+    while (length <= max) {
+      const read = readSync(fd, scratch, 0, CHUNK, null);
+      if (read === 0) break;
+      chunks.push(Buffer.from(scratch.subarray(0, read)));
+      length += read;
+    }
+    if (length > max) return { reason: "too-large" };
+    return { text: Buffer.concat(chunks, length).toString("utf-8"), bytes: length };
+  } catch (error) {
+    return { reason: error && error.code === "ELOOP" ? "symlink" : "unreadable" };
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function collect(inputs, { cwd, ext = [], ignore = [], limits = LIMITS } = {}) {
+  const base = resolve(cwd);
+  const kinds = new Map(DEFAULT_EXT);
+  for (const extension of ext) kinds.set(String(extension).toLowerCase(), "template");
+  const kindOf = (path) => {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    return dot <= 0 ? null : kinds.get(name.slice(dot).toLowerCase()) ?? null;
+  };
+  const patterns = ignore.map(compile);
+  const folders = ignore.filter((pattern) => pattern.endsWith("/**")).map((pattern) => compile(pattern.slice(0, -3)));
+  const isIgnored = (path) => {
+    const parts = segmentsOf(path);
+    return patterns.some((pattern) => matchSegments(pattern, parts));
+  };
+  const isPruned = (path) => {
+    const parts = segmentsOf(path);
+    return folders.some((pattern) => matchSegments(pattern, parts)) || patterns.some((pattern) => matchSegments(pattern, parts));
+  };
+  const found = /* @__PURE__ */ new Map();
+  const skipped = /* @__PURE__ */ new Map();
+  const missing = [];
+  let ignored = 0;
+  let visited = 0;
+  let total = 0;
+  let stopped = false;
+  const rel = (absolute) => {
+    const path = relative(base, absolute);
+    return (sep === "/" ? path : path.split(sep).join("/")) || ".";
+  };
+  const skip = (path, reason) => {
+    if (!skipped.has(path)) skipped.set(path, reason);
+  };
+  function take(absolute, path, kind) {
+    if (found.has(path) || skipped.has(path)) return;
+    const result = readLimited(absolute, limits.fileBytes);
+    if (result.reason) return skip(path, result.reason);
+    if (total + result.bytes > limits.totalBytes) return skip(path, "read-limit");
+    total += result.bytes;
+    found.set(path, { path, kind, text: result.text });
+  }
+  function visit(absolute, depth, match, maxParts) {
+    const path = rel(absolute);
+    let stat;
+    try {
+      stat = lstatSync(absolute);
+    } catch {
+      return skip(path, "unreadable");
+    }
+    if (stat.isSymbolicLink()) {
+      if (match && !match(path)) return;
+      if (isIgnored(path)) ignored++;
+      else skip(path, "symlink");
+      return;
+    }
+    if (stat.isDirectory()) {
+      if (isPruned(path)) {
+        ignored++;
+        return;
+      }
+      if (depth > limits.depth) return skip(path, "too-deep");
+      if (maxParts !== null && segmentsOf(path).length >= maxParts) return;
+      walk(absolute, depth, match, maxParts);
+      return;
+    }
+    const kind = kindOf(path);
+    if (kind === null || match && !match(path)) return;
+    if (isIgnored(path)) {
+      ignored++;
+      return;
+    }
+    if (!stat.isFile()) return skip(path, "not-a-file");
+    take(absolute, path, kind);
+  }
+  function walk(directory, depth, match, maxParts) {
+    let handle;
+    try {
+      handle = opendirSync(directory);
+    } catch {
+      return skip(rel(directory), "unreadable");
+    }
+    const room = limits.entries - visited;
+    const names = [];
+    let more = false;
+    try {
+      for (let entry = handle.readSync(); entry !== null; entry = handle.readSync()) {
+        if (names.length >= room) {
+          more = true;
+          break;
+        }
+        names.push(entry.name);
+      }
+    } catch {
+      skip(rel(directory), "unreadable");
+    } finally {
+      try {
+        handle.closeSync();
+      } catch {
+      }
+    }
+    visited += names.length;
+    for (const name of names.sort(byText)) {
+      if (stopped) return;
+      if (NEVER_ENTERED.has(name)) continue;
+      visit(resolve(directory, name), depth + 1, match, maxParts);
+    }
+    if (more && !stopped) {
+      stopped = true;
+      skip(rel(directory), "too-many-files");
+    }
+  }
+  for (const raw of inputs) {
+    if (stopped) break;
+    const input = String(raw);
+    if (hasWildcard(input)) {
+      const segments = input.split("/");
+      const first = segments.findIndex(hasWildcard);
+      const prefix = segments.slice(0, first).join("/");
+      const start = resolve(base, prefix === "" && input.startsWith("/") ? "/" : prefix);
+      const startPath = rel(start);
+      const pattern = compile([...startPath === "." ? [] : [startPath], ...segments.slice(first)].join("/"));
+      let hits = 0;
+      const match = (path2) => {
+        const matches2 = matchSegments(pattern, segmentsOf(path2));
+        if (matches2) hits++;
+        return matches2;
+      };
+      let isFolder = false;
+      try {
+        isFolder = lstatSync(start).isDirectory();
+      } catch {
+      }
+      if (isFolder) walk(start, 0, match, pattern.includes(null) ? null : pattern.length);
+      if (hits === 0) missing.push(input);
+      continue;
+    }
+    const absolute = resolve(base, input);
+    let stat;
+    try {
+      stat = lstatSync(absolute);
+    } catch {
+      missing.push(input);
+      continue;
+    }
+    const path = rel(absolute);
+    if (stat.isDirectory() && !stat.isSymbolicLink()) {
+      if (path !== "." && isPruned(path)) ignored++;
+      else walk(absolute, 0, null, null);
+    } else if (stat.isSymbolicLink() || kindOf(path) !== null) {
+      visit(absolute, 0, null, null);
+    } else missing.push(input);
+  }
+  return {
+    files: [...found.values()].sort((a, b) => byText(a.path, b.path)),
+    skipped: [...skipped].map(([file, reason]) => ({ file, reason })).sort((a, b) => byText(a.file, b.file)),
+    missing,
+    ignored
+  };
+}
+
+// packages/check/src/manifests.js
+var PACKAGES = ["tokens", "core", "site", "landing", "cms", "app", "docs"];
+var MAX_MANIFEST_BYTES = 8 * 1024 * 1024;
+var MAX_PACKAGE_JSON_BYTES = 256 * 1024;
+var MAX_CLASSES = 5e4;
+var MAX_ELEMENTS = 2e3;
+var MAX_ATTRIBUTES = 1e3;
+var MAX_HOOKS = 2e3;
+var MAX_PROPERTIES = 2e4;
+var MAX_TOKENS_BYTES = 1024 * 1024;
+var NAME = /^[A-Za-z0-9_:.\-/]{1,64}$/;
+var TAG = /^[a-z][a-z0-9-]{0,63}$/;
+var HOOK = /^data-luz-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var HOST = /^[a-z][a-z0-9]{0,31}(?:\[[a-z][a-z-]{0,31}(?:=[A-Za-z0-9_-]{1,32})?\])?$/;
+var MAX_HOSTS = 16;
+var VERSION = /^[0-9A-Za-z.+_-]{1,40}$/;
+var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isName = (value) => typeof value === "string" && NAME.test(value) && !FORBIDDEN.has(value);
+function readJson(path, max) {
+  const read = readLimited(path, max);
+  if (read.reason !== void 0) return null;
+  try {
+    return JSON.parse(read.text);
+  } catch {
+    return null;
+  }
+}
+function parseClasses(data, pkg) {
+  if (!isObject(data) || data.schema !== 1 || data.package !== `@luz-ds/${pkg}`) return null;
+  if (typeof data.version !== "string" || !VERSION.test(data.version)) return null;
+  if (!Array.isArray(data.classes) || data.classes.length > MAX_CLASSES) return null;
+  const classes = [];
+  for (const entry of data.classes) {
+    if (!isObject(entry) || !isName(entry.name)) return null;
+    for (const key of ["block", "modifier", "part"]) if (entry[key] !== void 0 && !isName(entry[key])) return null;
+    const { hosts } = entry;
+    if (hosts !== void 0 && !(Array.isArray(hosts) && hosts.length > 0 && hosts.length <= MAX_HOSTS && hosts.every((host) => typeof host === "string" && HOST.test(host)))) return null;
+    classes.push({ name: entry.name, block: entry.block, kind: entry.kind, defined: entry.defined, modifier: entry.modifier, part: entry.part, hosts });
+  }
+  if (data.properties !== void 0 && !Array.isArray(data.properties)) return null;
+  const properties = (data.properties ?? []).slice(0, MAX_PROPERTIES).filter((entry) => isObject(entry) && isName(entry.name) && (entry.scope === "root" || entry.scope === "component"));
+  let hooks = [];
+  if (data.hooks !== void 0) {
+    if (!Array.isArray(data.hooks) || data.hooks.length > MAX_HOOKS || !data.hooks.every((hook) => typeof hook === "string" && HOOK.test(hook))) return null;
+    hooks = data.hooks;
+  }
+  return { version: data.version, classes, properties, hooks };
+}
+function parseElements(data) {
+  if (!isObject(data) || !Array.isArray(data.modules) || data.modules.length > MAX_ELEMENTS) return null;
+  const elements = [];
+  for (const module of data.modules) {
+    if (!isObject(module)) return null;
+    if (module.declarations === void 0) continue;
+    if (!Array.isArray(module.declarations)) return null;
+    for (const declaration of module.declarations) {
+      if (!isObject(declaration)) return null;
+      if (declaration.tagName === void 0) continue;
+      if (typeof declaration.tagName !== "string" || !TAG.test(declaration.tagName)) return null;
+      const attributes = [];
+      if (declaration.attributes !== void 0) {
+        if (!Array.isArray(declaration.attributes) || declaration.attributes.length > MAX_ATTRIBUTES) return null;
+        for (const attribute of declaration.attributes) {
+          if (!isObject(attribute) || !isName(attribute.name)) return null;
+          attributes.push(attribute.name);
+        }
+      }
+      elements.push({ tag: declaration.tagName, attributes });
+    }
+  }
+  return elements;
+}
+function readPackage(classesPath, elementsPath, pkg) {
+  const data = readJson(classesPath, MAX_MANIFEST_BYTES);
+  if (data === null) return null;
+  const classes = parseClasses(data, pkg);
+  if (classes === null) return null;
+  let elements = [];
+  const present = readLimited(elementsPath, MAX_MANIFEST_BYTES);
+  if (present.reason === "too-large" || present.reason === "symlink" || present.reason === "not-a-file") return null;
+  if (present.reason === void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(present.text);
+    } catch {
+      return null;
+    }
+    elements = parseElements(parsed);
+    if (elements === null) return null;
+  }
+  return { ...classes, elements };
+}
+function readText(path, max) {
+  const read = readLimited(path, max);
+  return read.reason === void 0 ? read.text : null;
+}
+function buildWorld(parts) {
+  const classes = /* @__PURE__ */ new Set();
+  const blocks = /* @__PURE__ */ new Set();
+  const tags = /* @__PURE__ */ new Map();
+  const hooks = /* @__PURE__ */ new Set();
+  const versions = /* @__PURE__ */ new Map();
+  const packages = [];
+  const names = { luz: [], o: [], u: [] };
+  const info = /* @__PURE__ */ new Map();
+  const properties = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    packages.push({ package: `@luz-ds/${part.name}`, version: part.version, source: part.source });
+    versions.set(part.name, { version: part.version, source: part.source });
+    for (const { name, block, ...rest } of part.classes) {
+      if (!classes.has(name)) {
+        classes.add(name);
+        info.set(name, { block, ...rest, package: part.name });
+        if (name.startsWith("luz-")) names.luz.push(name);
+        else if (name.startsWith("o-")) names.o.push(name);
+        else if (name.startsWith("u-")) names.u.push(name);
+      }
+      if (block !== void 0) blocks.add(block);
+    }
+    for (const hook of part.hooks) hooks.add(hook);
+    for (const { name, scope } of part.properties) if (scope === "root" || !properties.has(name)) properties.set(name, scope);
+    for (const { tag, attributes } of part.elements) {
+      let known = tags.get(tag);
+      if (known === void 0) {
+        known = { attributes: /* @__PURE__ */ new Set(), package: part.name };
+        tags.set(tag, known);
+      }
+      for (const attribute of attributes) {
+        known.attributes.add(attribute);
+        if (attribute.startsWith("data-luz-")) hooks.add(attribute);
+      }
+    }
+  }
+  for (const list of Object.values(names)) list.sort();
+  const publicNames = [...properties].filter(([, scope]) => scope === "root").map(([name]) => name).sort();
+  return { packages, classes, blocks, tags, tagNames: [...tags.keys()].sort(), hooks, versions, byPrefix: names, info, properties, publicNames };
+}
+function createFacts({ data }) {
+  const bundled = /* @__PURE__ */ new Map();
+  const installed = /* @__PURE__ */ new Map();
+  const worlds = /* @__PURE__ */ new Map();
+  const shared = /* @__PURE__ */ new Map();
+  const ids = /* @__PURE__ */ new Map();
+  const fromSnapshot = (pkg) => {
+    if (bundled.has(pkg)) return bundled.get(pkg);
+    let part = null;
+    if (typeof data === "string" && data !== "") {
+      const folder = join(data, pkg);
+      const read = readPackage(join(folder, "classes.json"), join(folder, "custom-elements.json"), pkg);
+      if (read !== null) part = { name: pkg, source: "bundled", ...read };
+    }
+    bundled.set(pkg, part);
+    return part;
+  };
+  const fromFolder = (folder, pkg) => {
+    if (installed.has(folder)) return installed.get(folder);
+    let part = null;
+    const named = readJson(join(folder, "package.json"), MAX_PACKAGE_JSON_BYTES);
+    if (isObject(named) && named.name === `@luz-ds/${pkg}`) {
+      const read = readPackage(join(folder, "dist", "classes.json"), join(folder, "dist", "custom-elements.json"), pkg);
+      if (read !== null) part = { name: pkg, source: "node_modules", ...read };
+    }
+    installed.set(folder, part);
+    return part;
+  };
+  function forDirectory(directory) {
+    const cached = worlds.get(directory);
+    if (cached !== void 0) return cached;
+    const parts = [];
+    for (const pkg of PACKAGES) {
+      let part = null;
+      for (let current = directory; ; ) {
+        part = fromFolder(join(current, "node_modules", "@luz-ds", pkg), pkg);
+        if (part !== null) break;
+        const parent = dirname(current);
+        if (parent === current) break;
+        current = parent;
+      }
+      part ??= fromSnapshot(pkg);
+      if (part !== null) parts.push(part);
+    }
+    const key = parts.map((part) => ids.get(part) ?? ids.set(part, ids.size).get(part)).join(",");
+    let world = shared.get(key);
+    if (world === void 0) {
+      world = buildWorld(parts);
+      shared.set(key, world);
+    }
+    worlds.set(directory, world);
+    return world;
+  }
+  const tokenFiles = /* @__PURE__ */ new Map();
+  function tokensFor(directory, bundled2 = false) {
+    for (let current = directory; !bundled2; ) {
+      const folder = join(current, "node_modules", "@luz-ds", "tokens");
+      if (!tokenFiles.has(folder)) {
+        const named = readJson(join(folder, "package.json"), MAX_PACKAGE_JSON_BYTES);
+        tokenFiles.set(folder, isObject(named) && named.name === "@luz-ds/tokens" ? readText(join(folder, "dist", "tokens.css"), MAX_TOKENS_BYTES) : null);
+      }
+      const text2 = tokenFiles.get(folder);
+      if (text2 !== null) return { text: text2, source: "node_modules" };
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    const text = typeof data === "string" && data !== "" ? readText(join(data, "tokens", "tokens.css"), MAX_TOKENS_BYTES) : null;
+    return text === null ? null : { text, source: "bundled" };
+  }
+  return { forDirectory, tokensFor };
+}
+
+// packages/check/src/report.js
+var MAX_FINDINGS_PER_FILE = 200;
+var MAX_FINDINGS2 = 5e3;
+var byText2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var at = (value) => typeof value === "number" ? value : Infinity;
+function finding(key, { file, line = null, column = null, vars = {}, suggestion = null, details } = {}) {
+  const text = message(key, vars);
+  const rule = key.split(":")[0];
+  const found = {
+    rule,
+    severity: MESSAGES[key].severity,
+    file,
+    line: line ?? null,
+    column: column ?? null,
+    message: text,
+    suggestion: suggestion ?? null,
+    docs: docsUrl(rule)
+  };
+  if (details !== void 0) found.details = details;
+  return found;
+}
+var order = (a, b) => byText2(a.file, b.file) || at(a.line) - at(b.line) || at(a.column) - at(b.column) || byText2(a.rule, b.rule);
+function capped(all) {
+  const ranked = all.slice().sort((a, b) => a.severity === b.severity ? order(a, b) : a.severity === "block" ? -1 : 1);
+  const perFile = /* @__PURE__ */ new Map();
+  const kept = [];
+  for (const found of ranked) {
+    const count = perFile.get(found.file) ?? 0;
+    if (count >= MAX_FINDINGS_PER_FILE || kept.length >= MAX_FINDINGS2) continue;
+    perFile.set(found.file, count + 1);
+    kept.push(found);
+  }
+  return { kept: kept.sort(order), truncated: kept.length < all.length };
+}
+function buildReport({ version: version2, files = [], manifests = [], findings = [], skipped = [], config = {}, ignored = 0, strict = false }) {
+  const escaped = /* @__PURE__ */ new Map();
+  const shown2 = (path) => {
+    let text = escaped.get(path);
+    if (text === void 0) escaped.set(path, text = displayPath(path));
+    return text;
+  };
+  const skippedList = skipped.map(({ file, reason }) => ({ file: shown2(file), reason })).sort((a, b) => byText2(a.file, b.file) || byText2(a.reason, b.reason));
+  const all = [
+    ...findings.map((found) => shown2(found.file) === found.file ? found : { ...found, file: shown2(found.file) }),
+    ...skippedList.map(({ file, reason }) => finding("file/skipped", { file, vars: { reason } }))
+  ];
+  const blocking = all.filter((found) => found.severity === "block").length;
+  const warnings = all.length - blocking;
+  const { kept, truncated } = capped(all);
+  const off = [...config.off ?? []].sort(byText2);
+  return {
+    tool: "@luz-ds/check",
+    version: cleanText(version2, 40),
+    ok: blocking === 0 && !(strict && warnings > 0),
+    files: files.map(shown2).sort(byText2),
+    manifests: manifests.map(({ package: name, version: has2, source }) => ({ package: cleanText(name, 64), version: cleanText(has2, 40), source: cleanText(source, 20) })),
+    summary: { files: files.length, blocking, warnings, skipped: skippedList.length, ignored, off: off.length, truncated },
+    config: { file: config.file === null || config.file === void 0 ? null : shown2(config.file), off },
+    findings: kept,
+    skipped: skippedList
+  };
+}
+var MARK = { block: "\u2717", warn: "!" };
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function formatText(report) {
+  const lines2 = report.findings.flatMap((found) => {
+    const position = found.line === null ? "" : found.column === null ? `:${found.line}` : `:${found.line}:${found.column}`;
+    const head = `${MARK[found.severity]} ${found.file}${position} ${found.rule}  ${found.message}`;
+    const places = (found.details?.overrides ?? []).map((o) => `    ${o.token}${o.value === void 0 || o.value === null ? "" : `: ${o.value}`} is set in ${o.file}:${o.line}`);
+    return [head, ...places];
+  });
+  const { summary } = report;
+  const parts = [`${report.ok ? "\u2713" : "\u2717"} ${summary.blocking} blocking and ${plural(summary.warnings, "warning")} in ${plural(summary.files, "file")}`];
+  if (summary.ignored > 0) parts.push(`${summary.ignored} ignored`);
+  if (summary.off > 0) parts.push(`${summary.off} off`);
+  if (summary.truncated) parts.push("output cut, the totals above are complete");
+  let line = parts.join(", ");
+  if ((summary.ignored > 0 || summary.off > 0) && report.config.file !== null) line += ` (${report.config.file})`;
+  if (!report.ok && summary.blocking === 0) line += " (--strict: a warning fails)";
+  if (report.manifests.length > 0) line += ` (manifests: ${report.manifests.map((m) => `${m.package} ${m.version} from ${m.source}`).join(", ")})`;
+  lines2.push(line);
+  return `${lines2.join("\n")}
+`;
+}
+function formatJson(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+
+// packages/check/src/rules/load.js
+import { posix } from "node:path";
+
+// packages/tokens/lib/contrast.js
+var NAMED = { transparent: [0, 0, 0, 0], white: [255, 255, 255, 1], black: [0, 0, 0, 1] };
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+function hslToRgb(h, s, l) {
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0) * 255, f(8) * 255, f(4) * 255];
+}
+function parseColor(value) {
+  const text = String(value).trim().toLowerCase();
+  if (text in NAMED) {
+    const [r, g, b, a] = NAMED[text];
+    return { r, g, b, a };
+  }
+  const hex = text.match(/^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/)?.[1];
+  if (hex) {
+    const full = hex.length <= 4 ? [...hex].map((c) => c + c).join("") : hex;
+    const byte = (i) => parseInt(full.slice(i, i + 2), 16);
+    return { r: byte(0), g: byte(2), b: byte(4), a: full.length === 8 ? byte(6) / 255 : 1 };
+  }
+  const fn = text.match(/^(rgba?|hsla?)\(([^)]+)\)$/);
+  if (fn) {
+    const parts = fn[2].split(/[\s,/]+/).filter(Boolean);
+    const number = (p, scale = 1) => p.endsWith("%") ? parseFloat(p) / 100 * scale : parseFloat(p);
+    if (parts.length >= 3 && parts.length <= 4 && parts.every((p) => !Number.isNaN(parseFloat(p)))) {
+      const a = parts[3] === void 0 ? 1 : clamp(number(parts[3], 1), 0, 1);
+      if (fn[1].startsWith("rgb")) {
+        const [r2, g2, b2] = parts.slice(0, 3).map((p) => clamp(number(p, 255), 0, 255));
+        return { r: r2, g: g2, b: b2, a };
+      }
+      const [r, g, b] = hslToRgb((parseFloat(parts[0]) % 360 + 360) % 360, clamp(number(parts[1], 1), 0, 1), clamp(number(parts[2], 1), 0, 1));
+      return { r, g, b, a };
+    }
+  }
+  throw new Error(`cannot read the colour "${value}": write it as #rrggbb, rgb(), rgba(), hsl() or hsla()`);
+}
+var over = (top, bottom) => ({
+  r: top.r * top.a + bottom.r * (1 - top.a),
+  g: top.g * top.a + bottom.g * (1 - top.a),
+  b: top.b * top.a + bottom.b * (1 - top.a),
+  a: 1
+});
+var luminance = ({ r, g, b }) => {
+  const c = (v) => (v /= 255) <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
+};
+var ratio = (x, y) => {
+  const [a, b] = [luminance(x), luminance(y)];
+  return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+};
+var formatRatio = (value) => `${(Math.floor(value * 10 + 1e-9) / 10).toFixed(1)}:1`;
+var SURFACES = ["surface-page", "surface", "surface-hover", "surface-muted", "input-bg"];
+var STATUS = ["success", "danger", "warning", "info", "teal", "purple"];
+var CODE = ["comment", "keyword", "name", "property", "string", "literal"].map((t) => `code-${t}`);
+var PAIRS = [
+  // Text and links on the surfaces they sit on
+  { fg: ["text-primary", "text-secondary", "brand-primary", "brand-hover"], bg: SURFACES, min: 4.5, kind: "text" },
+  { fg: ["text-primary", "text-secondary"], bg: ["surface-strong", "surface-pressed"], min: 4.5, kind: "text" },
+  { fg: ["text-muted"], bg: ["input-bg", "surface-page", "surface"], min: 4.5, kind: "text" },
+  { fg: ["text-disabled"], bg: ["surface-page", "surface", "input-bg", "surface-muted", "surface-strong"], min: 3, kind: "disabled-text" },
+  // Text on solid fills
+  { fg: ["text-on-fill"], bg: ["brand-fill", "brand-fill-hover", "brand-fill-active", "color-danger-fill"], min: 4.5, kind: "text" },
+  // Sidebar
+  { fg: ["sidebar-text", "sidebar-label", "sidebar-text-hover"], bg: ["sidebar-bg"], min: 4.5, kind: "text" },
+  { fg: ["sidebar-text-hover"], bg: ["sidebar-hover"], min: 4.5, kind: "text" },
+  { fg: ["sidebar-active-text"], bg: ["sidebar-active-bg"], min: 4.5, kind: "text" },
+  // Status text on its tint (alerts, tags), also on a hovered row
+  ...STATUS.map((s) => ({
+    fg: [`color-${s}`],
+    bg: [`color-${s}-bg > surface-page`, `color-${s}-bg > surface`, `color-${s}-bg > surface-hover`],
+    min: 4.5,
+    kind: "text"
+  })),
+  { fg: ["color-code"], bg: ["surface-page", "surface", "surface-muted"], min: 4.5, kind: "text" },
+  // Non-text: focus ring, field boundaries, outlines (WCAG 1.4.11)
+  { fg: ["focus-ring"], bg: [...SURFACES, "surface-strong"], min: 3, kind: "ui" },
+  { fg: ["input-border"], bg: ["input-bg"], min: 3, kind: "ui" },
+  { fg: ["outline"], bg: ["surface-page", "surface"], min: 3, kind: "ui" },
+  // Progress and player seek bars: the fill on the track (surface-muted) and the
+  // played part on the buffered part (surface-pressed)
+  { fg: ["brand-primary"], bg: ["surface-muted", "surface-pressed"], min: 3, kind: "ui" },
+  // Also on the strong surface (tooltip, toast, table header) and as plain text
+  // on every surface: status and code colours and their tints keep 4.5:1 there
+  ...STATUS.map((s) => ({
+    fg: [`color-${s}`],
+    bg: [`color-${s}-bg > surface-strong`, "surface-page", "surface", "surface-hover", "surface-muted", "surface-strong"],
+    min: 4.5,
+    kind: "text"
+  })),
+  { fg: ["color-code"], bg: ["surface-strong"], min: 4.5, kind: "text" },
+  // Syntax colours on the code block (.luz-code-block sits on surface-muted)
+  { fg: CODE, bg: ["surface-muted"], min: 4.5, kind: "text" },
+  // The field border on every surface a field can sit on (WCAG 1.4.11)
+  { fg: ["input-border"], bg: [...SURFACES, "surface-strong"], min: 3, kind: "ui" },
+  // .luz-badge--gray: white text on the outline colour
+  { fg: ["text-on-fill"], bg: ["outline"], min: 4.5, kind: "text" },
+  // The error mark of a form field, on the field itself (select, input)
+  { fg: ["color-danger"], bg: ["input-bg"], min: 3, kind: "ui" },
+  // What the component pages print and no row above covers: the body text of
+  // an alert on its tint, a link or an avatar on the brand tint, the checked
+  // box and the active sidebar entry as shapes, text on a video
+  { fg: ["text-primary", "text-secondary"], bg: STATUS.map((s) => `color-${s}-bg > surface-page`), min: 4.5, kind: "text" },
+  { fg: ["text-primary", "text-secondary", "brand-primary"], bg: ["brand-subtle > surface-page"], min: 4.5, kind: "text" },
+  // A primary button and a focus ring on the brand tint (a band, a hovered
+  // outline button): 1.4.11, strict. In dark mode the fill is the thinnest
+  // pair of the system, so a change to the tint or the fill fails here first
+  { fg: ["brand-fill", "focus-ring"], bg: ["brand-subtle > surface-page"], min: 3, kind: "ui" },
+  // A checked box and a switch track are told apart by their mark and their
+  // border, so their fill on the page is a stricter aim than WCAG 1.4.11
+  // needs: reported, never failing
+  { fg: ["brand-fill"], bg: ["surface-page", "surface"], min: 3, kind: "ui", advisory: true },
+  { fg: ["brand-primary"], bg: ["surface-strong"], min: 3, kind: "ui" },
+  { fg: ["sidebar-active-bg"], bg: ["sidebar-bg"], min: 3, kind: "ui" },
+  { fg: ["text-on-fill"], bg: ["surface-media"], min: 4.5, kind: "text" },
+  // Site's bands (notice, cookie banner): a link and a focus ring on the
+  // warning notice, a primary button's edge on the muted band, and the edge
+  // of a checkbox on its field surface
+  { fg: ["brand-primary"], bg: ["color-warning-bg > surface-page"], min: 4.5, kind: "text" },
+  { fg: ["focus-ring"], bg: ["color-warning-bg > surface-page"], min: 3, kind: "ui" },
+  { fg: ["brand-fill"], bg: ["surface-muted"], min: 3, kind: "ui" },
+  { fg: ["outline"], bg: ["input-bg"], min: 3, kind: "ui" }
+];
+var HIGH_CONTRAST_PAIRS = [{ fg: CODE, bg: ["surface-muted"], min: 7, kind: "text" }];
+var pairsFor = (mode) => mode === "high-contrast" ? [...PAIRS, ...HIGH_CONTRAST_PAIRS] : PAIRS;
+function expandPairs(pairs) {
+  const out = [];
+  for (const { fg, bg, min, kind, advisory = false } of pairs) for (const f of fg) for (const b of bg) out.push({ fg: f, bg: b, min, kind, advisory });
+  return out;
+}
+var VAR = /^var\(\s*(--[\w-]+)\s*(?:,\s*([^)]+))?\)$/;
+function createResolver(values) {
+  function resolve3(name, chain = []) {
+    if (chain.includes(name)) throw new Error(`${name} refers to itself`);
+    const raw = values[name];
+    if (raw === void 0) throw new Error(`${name} is not defined`);
+    const ref = raw.match(VAR);
+    if (!ref) return { value: raw, chain: [...chain, name] };
+    if (values[ref[1]] === void 0 && ref[2]) return { value: ref[2].trim(), chain: [...chain, name] };
+    return resolve3(ref[1], [...chain, name]);
+  }
+  return resolve3;
+}
+function measure(resolve3, pairs) {
+  const results = [];
+  const unreadable = [];
+  const colour = (name) => {
+    const { value, chain } = resolve3(`--luz-${name}`);
+    try {
+      return { colour: parseColor(value), chain };
+    } catch (error) {
+      error.tokens = chain;
+      throw error;
+    }
+  };
+  const surface = (spec) => {
+    const layers = spec.split(">").map((s) => s.trim());
+    let result = colour("surface-page").colour;
+    const chain = [];
+    for (const layer of layers.reverse()) {
+      const c = colour(layer);
+      chain.push(...c.chain);
+      result = over(c.colour, result);
+    }
+    return { colour: result, chain };
+  };
+  for (const { fg, bg, min, kind, advisory } of expandPairs(pairs)) {
+    try {
+      const back = surface(bg);
+      const front = colour(fg);
+      const value = ratio(over(front.colour, back.colour), back.colour);
+      results.push({ foreground: `--luz-${fg}`, background: bg, ratio: value, minimum: min, kind, advisory, ok: value + 1e-9 >= min, tokens: [...front.chain, ...back.chain] });
+    } catch (error) {
+      unreadable.push({ foreground: `--luz-${fg}`, background: bg, reason: error.message, tokens: error.tokens ?? [] });
+    }
+  }
+  return { results, unreadable };
+}
+
+// packages/check/src/rules/shared.js
+var SUGGESTIONS_PER_FILE = 200;
+var SUGGESTIONS_IN_ALL = 5e3;
+var PACKAGE_PREFIXES = [
+  ["luz-landing-", "landing"],
+  ["luz-cms-", "cms"],
+  ["luz-app-", "app"],
+  ["luz-docs-", "docs"],
+  ["luz-site-", "site"]
+];
+function packageOfName(name) {
+  for (const [prefix, pkg] of PACKAGE_PREFIXES) if (name.startsWith(prefix)) return pkg;
+  return "core";
+}
+var isEcho = (name) => echoName(name) === name;
+var TOKEN_SKIP = /[{}$:@[]/;
+var VALUE_SKIP = /[{}$<%@(]/;
+var SPACE2 = /[ \t\n\r\f]+/;
+var classAttribute = (record, template) => record.attrs.get("class") ?? (template ? record.attrs.get("classname") : void 0);
+function classTokens(value, template) {
+  if (template && VALUE_SKIP.test(value)) return [];
+  return value.split(SPACE2).filter((token) => token.length >= 3 && !TOKEN_SKIP.test(token));
+}
+function createBudget() {
+  const total = /* @__PURE__ */ new Map();
+  return () => {
+    const own = /* @__PURE__ */ new Map();
+    return (rule) => {
+      const here = own.get(rule) ?? 0;
+      const all = total.get(rule) ?? 0;
+      if (here >= SUGGESTIONS_PER_FILE || all >= SUGGESTIONS_IN_ALL) return false;
+      own.set(rule, here + 1);
+      total.set(rule, all + 1);
+      return true;
+    };
+  };
+}
+function toHex(value) {
+  try {
+    const { r, g, b, a } = parseColor(value);
+    return a === 1 ? `#${[r, g, b].map((n) => Math.round(n).toString(16).padStart(2, "0")).join("")}` : null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/check/src/rules/load.js
+var TEMPLATE = /\{\{|<%|\$\{/;
+var IN_URL = /@luz-ds\/(tokens|core|site|landing|cms|app|docs)(?![\w-])/;
+var IN_DEV = /\/packages\/(tokens|core|site|landing|cms|app|docs)\//;
+var FILE = /^(?:luz(-tokens)?|(site|landing|cms|app|docs))(?:\.min)?\.css$/;
+var IMPORT = /@import\s+(?:url\(\s*)?["']?([^"')\s;]+)/g;
+var LAYER = /@layer\s+([^;{}@]{0,512})([;{}])/g;
+var STYLESHEET = /(?:^|\s)stylesheet(?:\s|$)/i;
+var REMOTE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+var ORDER = ["tokens", "core", "site"];
+function classify(url) {
+  if (TEMPLATE.test(url)) return "template";
+  const named = IN_URL.exec(url) ?? IN_DEV.exec(url);
+  if (named !== null) return { pkg: named[1], copy: false };
+  const file = FILE.exec(url.split(/[?#]/)[0].split("/").pop().toLowerCase());
+  if (file === null) return null;
+  return { pkg: file[2] ?? (file[1] ? "tokens" : "core"), copy: file[2] !== void 0 };
+}
+function withoutComments(text) {
+  let out = "";
+  for (let from = 0; ; ) {
+    const open = text.indexOf("/*", from);
+    const close = open === -1 ? -1 : text.indexOf("*/", open + 2);
+    if (close === -1) return out + (open === -1 ? text.slice(from) : "");
+    out += text.slice(from, open);
+    from = close + 2;
+  }
+}
+function importsOf(css) {
+  return css.includes("@import") ? [...withoutComments(css).matchAll(IMPORT)].map((m) => m[1]) : [];
+}
+function runPath(from, url) {
+  const target = url.split(/[?#]/)[0];
+  if (target === "" || REMOTE.test(target)) return null;
+  return posix.normalize(target.startsWith("/") ? target.slice(1) : posix.join(posix.dirname(from), target));
+}
+function follow(url, from, imports, visit) {
+  const seen = /* @__PURE__ */ new Set([from]);
+  const work = [[url, from]];
+  while (work.length > 0) {
+    const [current, base] = work.pop();
+    if (visit(current) !== false) continue;
+    const next = runPath(base, current);
+    if (next === null || seen.has(next)) continue;
+    seen.add(next);
+    const list = imports.get(next) ?? [];
+    for (let i = list.length - 1; i >= 0; i--) work.push([list[i], next]);
+  }
+}
+function reachesLuz(path, imports) {
+  let reached = false;
+  for (const url of imports.get(path) ?? []) {
+    follow(url, path, imports, (current) => {
+      const known = classify(current);
+      if (known !== null) reached = true;
+      return known !== null;
+    });
+    if (reached) return true;
+  }
+  return false;
+}
+function documentOf(records, path, imports) {
+  const doc = { entries: [], styles: [], dynamic: false, bundled: false, inline: false, page: false };
+  const add = (url, record, n) => follow(url, path, imports, (current) => {
+    const known = classify(current);
+    if (known === null) return false;
+    if (known === "template") doc.dynamic = true;
+    else doc.entries.push({ pkg: known.pkg, copy: known.copy, record, n });
+    return true;
+  });
+  records.forEach((record, n) => {
+    const { name, attrs } = record;
+    if (name === "link") {
+      const rel = attrs.get("rel");
+      const href = attrs.get("href");
+      if (rel !== void 0 && href !== void 0 && STYLESHEET.test(rel.value)) add(href.value, record, n);
+    } else if (name === "style" && record.text) {
+      for (const url of importsOf(record.text)) add(url, record, n);
+      if (!record.text.includes("@layer")) return;
+      for (const [, prelude, end] of withoutComments(record.text).matchAll(LAYER)) {
+        const layers = prelude.split(",").map((layer) => layer.trim());
+        if (layers.some((layer) => layer === "luz" || layer.startsWith("luz."))) doc.inline = true;
+        if (end === ";" && layers.includes("luz")) doc.styles.push({ record, n });
+      }
+    } else if (name === "html" || name === "head") doc.page = true;
+    else if (name === "script" && attrs.has("src") && (attrs.get("type")?.value.trim().toLowerCase() ?? "") === "module") doc.bundled = true;
+  });
+  return doc;
+}
+function loadRules(ctx) {
+  const { file, records, world, doc, template } = ctx;
+  const { entries } = doc;
+  const found = [];
+  const at2 = (record) => ({ file, line: record.line, column: record.column });
+  if (!doc.dynamic && entries.length > 0) {
+    if (!entries.some((entry) => entry.pkg === "tokens")) {
+      const first2 = entries.find((entry) => !entry.copy);
+      if (first2 !== void 0) found.push(finding("load/tokens-missing", { ...at2(first2.record), vars: { package: first2.pkg } }));
+    }
+    const loaded = new Set(entries.map((entry) => entry.pkg));
+    const missing = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      const owner = record.name.startsWith("luz-") ? world.tags.get(record.name)?.package : void 0;
+      if (owner !== void 0 && !loaded.has(owner) && !missing.has(owner)) {
+        missing.add(owner);
+        found.push(finding("load/package-missing:tag", { ...at2(record), vars: { tag: record.name, package: owner } }));
+      }
+      const attribute = classAttribute(record, template);
+      if (attribute === void 0) continue;
+      for (const token of classTokens(attribute.value, template)) {
+        const entry = world.info.get(token);
+        if (entry === void 0 || entry.kind === "state" || entry.defined === false || token.startsWith("is-")) continue;
+        if (loaded.has(entry.package) || missing.has(entry.package)) continue;
+        missing.add(entry.package);
+        found.push(finding("load/package-missing", { ...at2(attribute), vars: { name: token, package: entry.package } }));
+      }
+    }
+  }
+  const first = entries.find((entry) => !entry.copy);
+  if (first !== void 0 && !doc.styles.some((style) => style.n < first.n)) {
+    for (const style of doc.styles) if (style.n > first.n) found.push(finding("load/layer-statement", { ...at2(style.record), vars: { tag: "style" } }));
+  }
+  let top = null;
+  for (const entry of entries) {
+    if (entry.copy) continue;
+    const rank = ORDER.includes(entry.pkg) ? ORDER.indexOf(entry.pkg) : 3;
+    if (top !== null && rank < top.rank) {
+      found.push(finding("load/order", { file, vars: { first: top.pkg, second: entry.pkg } }));
+      break;
+    }
+    if (top === null || rank > top.rank) top = { rank, pkg: entry.pkg };
+  }
+  return found;
+}
+
+// packages/check/src/suggest.js
+var MAX_NAME = 64;
+var ROWS = [new Int32Array(MAX_NAME + 1), new Int32Array(MAX_NAME + 1), new Int32Array(MAX_NAME + 1)];
+function bounded(a, b, limit) {
+  const n = a.length;
+  const m = b.length;
+  if (Math.abs(n - m) > limit) return limit + 1;
+  const rows = m <= MAX_NAME ? ROWS : [new Int32Array(m + 1), new Int32Array(m + 1), new Int32Array(m + 1)];
+  let [previous, previous2, row] = rows;
+  for (let j = 0; j <= m; j++) previous[j] = j;
+  for (let i = 1; i <= n; i++) {
+    row[0] = i;
+    let least = row[0];
+    for (let j = 1; j <= m; j++) {
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      let value = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + cost);
+      if (i > 1 && j > 1 && a.charCodeAt(i - 1) === b.charCodeAt(j - 2) && a.charCodeAt(i - 2) === b.charCodeAt(j - 1)) {
+        value = Math.min(value, previous2[j - 2] + 1);
+      }
+      row[j] = value;
+      if (value < least) least = value;
+    }
+    if (least > limit) return limit + 1;
+    const spare = previous2;
+    previous2 = previous;
+    previous = row;
+    row = spare;
+  }
+  return Math.min(previous[m], limit + 1);
+}
+var limitOf = (length) => Math.min(Math.max(2, Math.ceil(length / 4)), Math.floor(0.4 * length));
+function closest(name, candidates, ceiling = Infinity) {
+  const text = String(name);
+  if (text.length === 0 || text.length > MAX_NAME) return null;
+  let limit = Math.min(limitOf(text.length), ceiling);
+  if (limit < 1) return null;
+  let best = null;
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string" || Math.abs(candidate.length - text.length) > limit) continue;
+    const found = bounded(text, candidate, limit);
+    if (found > limit) continue;
+    if (best === null || found < limit || candidate < best) {
+      best = candidate;
+      limit = found;
+    }
+  }
+  return best;
+}
+
+// packages/check/src/rules/css.js
+var NOISE = /"(?:\\[\s\S]|[^"\\\n])*"|'(?:\\[\s\S]|[^'\\\n])*'|url\([^)]*\)/gi;
+var COLOUR2 = /#[0-9a-f]{3,8}(?![\w-])|(?<![\w-])(?:(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color(?:-mix)?)\(|(?:white|black)(?![\w-]))/i;
+var SIZE_PROPERTY = /^(?:font-size|(?:row-|column-)?gap|border-radius|(?:margin|padding)(?:-[a-z-]+)?)$/;
+var LENGTH = /(?<![\w.-])[-+]?(?:\d+\.?\d*|\.\d+)(?:px|rem)(?![\w-])/gi;
+var PIXELS = /(?<![\w.-])(?:\d+\.?\d*|\.\d+)px(?![\w-])/i;
+var IMPORTANT = /!\s*important(?![\w-])/i;
+var READ2 = /var\(\s*(--luz-[\w-]*)/g;
+var KNOBS = /* @__PURE__ */ new Set(["--luz-type-base", "--luz-space-unit"]);
+var textual = /^(?:color|fill|stroke|caret-color|text-decoration-color)$/;
+var lines = /^(?:border|outline)/;
+var tokenFor = (property) => textual.test(property) ? "--luz-text-primary" : lines.test(property) ? "--luz-outline" : property.startsWith("box-shadow") ? "--luz-shadow-sm" : "--luz-surface";
+function functionAt(value, index) {
+  let depth = 0;
+  for (let i = value.indexOf("(", index); i !== -1 && i < value.length; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 40) depth++;
+    else if (c === 41 && --depth === 0) return value.slice(index, i + 1);
+  }
+  return null;
+}
+function cssRules({ file, css, text, world, take }) {
+  const { declarations } = css;
+  const found = [];
+  if (declarations.length === 0) return found;
+  const starts = lineStarts(text);
+  const hexes = /* @__PURE__ */ new Map();
+  let facts;
+  for (let at2 = 0; at2 < declarations.length; at2 += 3) {
+    const start = declarations[at2];
+    const name = text.slice(start, declarations[at2 + 1]).trim();
+    const custom = name.startsWith("--");
+    let value = text.slice(declarations[at2 + 1] + 1, declarations[at2 + 2]);
+    if (value.includes("/*")) value = withoutComments(value);
+    value = value.replace(NOISE, " ");
+    const line = lineAt(starts, start);
+    const where = { file, line, column: start - starts[line - 1] + 1 };
+    const property = custom ? name : name.toLowerCase();
+    if (IMPORTANT.test(value)) found.push(finding("css/important", { ...where, vars: { property } }));
+    if (custom) {
+      if (KNOBS.has(property) && PIXELS.test(value)) found.push(finding("css/knob-in-px", { ...where, vars: { property } }));
+    } else {
+      const colour = property.startsWith("font") ? null : COLOUR2.exec(value);
+      if (colour !== null) {
+        const literal = colour[0].endsWith("(") ? functionAt(value, colour.index) : colour[0];
+        let hex = literal === null ? null : hexes.get(literal);
+        if (hex === void 0) hexes.set(literal, hex = toHex(literal));
+        const vars = { property, token: tokenFor(property) };
+        found.push(hex === null ? finding("css/literal-colour:none", { ...where, vars }) : finding("css/literal-colour", { ...where, vars: { ...vars, value: hex } }));
+      }
+      if (SIZE_PROPERTY.test(property)) {
+        for (const match of value.matchAll(LENGTH)) {
+          if (Number.parseFloat(match[0]) === 0) continue;
+          found.push(finding("css/literal-size", { ...where, vars: { property, value: match[0] } }));
+          break;
+        }
+      }
+    }
+    if (!value.includes("--luz-") && !property.startsWith("--luz-")) continue;
+    const names = new Set(property.startsWith("--luz-") ? [property] : []);
+    for (const match of value.matchAll(READ2)) names.add(match[1]);
+    for (const token of names) {
+      facts ??= world();
+      if (facts === null) return found;
+      const scope = facts.properties.get(token);
+      if (scope === "root") continue;
+      if (scope === "component") {
+        found.push(finding("css/private-token", { ...where, vars: { token } }));
+        continue;
+      }
+      const near = isEcho(token) && take("css/unknown-token") ? closest(token, facts.publicNames) : null;
+      found.push(near === null ? finding("css/unknown-token:none", { ...where, vars: { token } }) : finding("css/unknown-token", { ...where, vars: { token, closest: near }, suggestion: near }));
+    }
+  }
+  return found;
+}
+
+// packages/check/src/rules/element.js
+var GLOBAL = /* @__PURE__ */ new Set([
+  "accesskey",
+  "anchor",
+  "autocapitalize",
+  "autocorrect",
+  "autofocus",
+  "class",
+  "contenteditable",
+  "dir",
+  "draggable",
+  "enterkeyhint",
+  "exportparts",
+  "hidden",
+  "id",
+  "inert",
+  "inputmode",
+  "is",
+  "itemid",
+  "itemprop",
+  "itemref",
+  "itemscope",
+  "itemtype",
+  "key",
+  "lang",
+  "nonce",
+  "part",
+  "popover",
+  "ref",
+  "role",
+  "slot",
+  "spellcheck",
+  "style",
+  "tabindex",
+  "title",
+  "translate",
+  "virtualkeyboardpolicy",
+  "writingsuggestions"
+]);
+var FRAMEWORK_PREFIX = ["v-", "x-", "hx-", "ng-", "on"];
+var BINDING = "@:*[(#{.";
+var PLAIN = /^[a-z_][a-z0-9_.-]*$/;
+function isAccepted(name, declared) {
+  if (declared.has(name) || GLOBAL.has(name)) return true;
+  if (name.startsWith("aria-")) return true;
+  if (name.startsWith("data-")) return !name.startsWith("data-luz-") || name.startsWith("data-luz-label-");
+  if (!PLAIN.test(name)) return true;
+  if (FRAMEWORK_PREFIX.some((prefix) => name.startsWith(prefix))) return true;
+  return BINDING.includes(name[0]);
+}
+function elementRules(ctx) {
+  const { file, records, world, take } = ctx;
+  const found = [];
+  for (const record of records) {
+    const tag = record.name;
+    if (tag.endsWith("-")) continue;
+    const declared = tag.startsWith("luz-") ? world.tags.get(tag) : void 0;
+    if (tag.startsWith("luz-") && declared === void 0 && !world.blocks.has(tag)) {
+      const near = isEcho(tag) && take("element/unknown") ? closest(tag, world.tagNames) : null;
+      const where = { file, line: record.line, column: record.column };
+      if (near === null) found.push(finding("element/unknown:none", { ...where, vars: { tag, package: packageOfName(tag) } }));
+      else found.push(finding("element/unknown", { ...where, vars: { tag, closest: near }, suggestion: `<${near}>` }));
+      continue;
+    }
+    for (const [name, attribute] of record.attrs) {
+      const where = { file, line: attribute.line, column: attribute.column };
+      if (declared !== void 0) {
+        if (isAccepted(name, declared.attributes)) continue;
+        const near = isEcho(name) && take("element/unknown-attribute") ? closest(name, declared.attributes) : null;
+        if (near === null) found.push(finding("element/unknown-attribute:none", { ...where, vars: { attribute: name, tag } }));
+        else found.push(finding("element/unknown-attribute", { ...where, vars: { attribute: name, tag, closest: near }, suggestion: near }));
+      } else if (name.startsWith("data-luz-") && !name.startsWith("data-luz-label-") && !world.hooks.has(name)) {
+        found.push(finding("attr/unknown-hook", { ...where, vars: { attribute: name } }));
+      }
+    }
+  }
+  return found;
+}
+
+// packages/check/src/rules/class.js
+var LINK = /@luz-ds\/(tokens|core|site|landing|cms|app|docs)@(\d{1,9})\.(\d{1,9})\.(\d{1,9})/g;
+var SEMVER = /^(\d{1,9})\.(\d{1,9})\.(\d{1,9})/;
+var nameOf = /* @__PURE__ */ new WeakMap();
+function newerRelease(records, world) {
+  for (const record of records) {
+    const url = record.name === "link" ? record.attrs.get("href") : record.name === "script" ? record.attrs.get("src") : void 0;
+    if (url === void 0 || !url.value.includes("@luz-ds/")) continue;
+    for (const match of url.value.matchAll(LINK)) {
+      const has2 = world.versions.get(match[1]);
+      if (has2 === void 0 || has2.source !== "bundled") continue;
+      const known = SEMVER.exec(has2.version);
+      if (known === null) continue;
+      const linked = [Number(match[2]), Number(match[3]), Number(match[4])];
+      const older = [Number(known[1]), Number(known[2]), Number(known[3])];
+      for (let i = 0; i < 3; i++) {
+        if (linked[i] === older[i]) continue;
+        if (linked[i] > older[i]) return { package: match[1], linked: linked.join("."), known: older.join(".") };
+        break;
+      }
+    }
+  }
+  return null;
+}
+function verdict(name, ctx) {
+  const { world, defined } = ctx;
+  if (name.startsWith("luz-")) return world.classes.has(name) ? null : { closest: void 0 };
+  const group = name.startsWith("o-") ? world.byPrefix.o : name.startsWith("u-") ? world.byPrefix.u : null;
+  if (group === null || world.classes.has(name) || defined.has(name)) return null;
+  for (const known of group) if (name.length > known.length && name.startsWith(known)) return null;
+  const near = closest(name, group, 2);
+  return near === null ? null : { closest: near };
+}
+function memoOf(world) {
+  let memo = nameOf.get(world);
+  if (memo === void 0) {
+    memo = /* @__PURE__ */ new Map();
+    nameOf.set(world, memo);
+  }
+  return memo;
+}
+function unknownClasses(ctx) {
+  const { file, records, template, take, world } = ctx;
+  const found = [];
+  const memo = memoOf(world);
+  let newer;
+  for (const record of records) {
+    const attribute = classAttribute(record, template);
+    if (attribute === void 0) continue;
+    for (const token of classTokens(attribute.value, template)) {
+      if (!token.startsWith("luz-") && !token.startsWith("o-") && !token.startsWith("u-")) continue;
+      let entry = memo.get(token);
+      if (entry === void 0) {
+        entry = verdict(token, ctx);
+        memo.set(token, entry);
+      }
+      if (entry === null) continue;
+      let near = entry.closest;
+      if (near === void 0) {
+        near = null;
+        if (isEcho(token) && take("class/unknown")) {
+          near = closest(token, world.byPrefix.luz);
+          entry.closest = near;
+        }
+      }
+      const where = { file, line: attribute.line, column: attribute.column };
+      const pkg = packageOfName(token);
+      if (token.startsWith("luz-")) {
+        if (newer === void 0) newer = newerRelease(records, world);
+        if (newer !== null) {
+          const details = { package: `@luz-ds/${newer.package}`, linked: newer.linked, known: newer.known };
+          found.push(finding("class/unknown:newer", { ...where, vars: { name: token, known: newer.known, linked: newer.linked, package: pkg }, details }));
+          continue;
+        }
+      }
+      if (near === null) found.push(finding("class/unknown:none", { ...where, vars: { name: token, package: pkg } }));
+      else found.push(finding("class/unknown", { ...where, vars: { name: token, closest: near }, suggestion: `.${near}` }));
+    }
+  }
+  return found;
+}
+function stylesheetClasses(ctx) {
+  const { file, css, world, take } = ctx;
+  const found = [];
+  const memo = memoOf(world);
+  for (const entry of css.classes) {
+    const { name } = entry;
+    if (!name.startsWith("luz-") || world.classes.has(name)) continue;
+    const where = { file, line: entry.line, column: entry.column };
+    if (entry.defined) {
+      found.push(finding("class/reserved-prefix", { ...where, vars: { name } }));
+      continue;
+    }
+    let near = null;
+    if (isEcho(name) && take("class/unknown-in-css")) {
+      const key = `css:${name}`;
+      if (memo.has(key)) near = memo.get(key);
+      else {
+        near = closest(name, world.byPrefix.luz);
+        memo.set(key, near);
+      }
+    }
+    if (near === null) found.push(finding("class/unknown-in-css:none", { ...where, vars: { name, package: packageOfName(name) } }));
+    else found.push(finding("class/unknown-in-css", { ...where, vars: { name, closest: near }, suggestion: `.${near}` }));
+  }
+  return found;
+}
+
+// packages/check/src/rules/misuse.js
+var TEMPLATE2 = /\{\{|<%|\$\{/;
+var COMPUTED = /[{}$<%@(]/;
+var CLASS_BINDING = /^(?:[:@]|v-bind:|x-bind:|\[|ng-)?(?:ng)?class(?:[:.\]].*)?$/;
+var HTML_NAME = /^[a-z][a-z0-9]*$/;
+var SELECTOR = /^([a-z0-9]+)(?:\[([a-z-]+)(?:=(.+))?\])?$/;
+var SPACE3 = /\s+/;
+var ROLES = new Map(
+  ["button button", "link a", "checkbox input", "radio input", "textbox input", "switch input", "dialog dialog", "navigation nav", "table table", "heading h1", "list ul", "main main"].map((pair) => pair.split(" "))
+);
+var has = (attrs, name) => attrs.has(name) || attrs.has(`:${name}`) || attrs.has(`[${name}]`) || attrs.has(`v-bind:${name}`) || attrs.has(`x-bind:${name}`);
+function matches(selector, record) {
+  const [, tag, attribute, value] = SELECTOR.exec(selector);
+  if (tag !== record.name) return false;
+  if (attribute === void 0) return true;
+  const own = record.attrs.get(attribute);
+  if (own === void 0) return has(record.attrs, attribute);
+  return value === void 0 || TEMPLATE2.test(own.value) || own.value.toLowerCase() === value;
+}
+function inside(record, block, template, memo) {
+  let table = memo.get(block);
+  if (table === void 0) memo.set(block, table = /* @__PURE__ */ new Map());
+  const trail = [];
+  let found = false;
+  for (let ancestor = record.parent; ancestor !== null; ancestor = ancestor.parent) {
+    const known = table.get(ancestor);
+    if (known !== void 0) {
+      found = known;
+      break;
+    }
+    trail.push(ancestor);
+    const attribute = classAttribute(ancestor, template);
+    if (ancestor.name === block || attribute !== void 0 && (COMPUTED.test(attribute.value) || attribute.value.split(SPACE3).includes(block))) {
+      found = true;
+      break;
+    }
+  }
+  for (const ancestor of trail) table.set(ancestor, found);
+  return found;
+}
+function misuseRules(ctx) {
+  const { file, records, world, defined, template } = ctx;
+  const found = [];
+  const memo = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const attribute = classAttribute(record, template);
+    const tokens = attribute === void 0 ? [] : [...new Set(classTokens(attribute.value, template))];
+    const own = attribute === void 0 ? null : { file, line: attribute.line, column: attribute.column };
+    const plain = record.written === record.name && HTML_NAME.test(record.name) && !record.inert;
+    let reported = false;
+    if (plain) {
+      for (const token of tokens) {
+        const hosts = world.info.get(token)?.hosts;
+        if (hosts === void 0 || hosts.some((host) => matches(host, record))) continue;
+        const names = [...new Set(hosts.map((host) => host.split("[")[0]))];
+        found.push(finding("misuse/host-element", { ...own, vars: { name: token, tag: record.name, hosts: names } }));
+        reported = true;
+        break;
+      }
+    }
+    if (tokens.length > 0) {
+      let bound = null;
+      for (const token of tokens) {
+        const entry = world.info.get(token);
+        if (entry === void 0) continue;
+        if (entry.modifier !== void 0) {
+          const block = token.slice(0, token.length - entry.modifier.length - 2);
+          if (record.name !== block && !tokens.includes(block)) {
+            bound ??= COMPUTED.test(attribute.value) || [...record.attrs.keys()].some((name) => name !== "class" && CLASS_BINDING.test(name));
+            if (!bound) found.push(finding("misuse/modifier-alone", { ...own, vars: { modifier: token, block } }));
+          }
+        }
+        if (entry.part !== void 0 && !inside(record, entry.block, template, memo)) {
+          found.push(finding("misuse/part-orphan", { ...own, vars: { name: token, block: entry.block } }));
+        }
+        if (token.startsWith("is-") && !defined.has(token)) found.push(finding("misuse/state-class", { ...own, vars: { name: token } }));
+      }
+    }
+    if (!plain) continue;
+    if ((record.name === "div" || record.name === "span") && !reported) {
+      const role = record.attrs.get("role");
+      const word = role === void 0 ? "" : role.value.trim().toLowerCase().split(SPACE3)[0];
+      const onclick = record.attrs.get("onclick");
+      if (ROLES.has(word)) {
+        found.push(finding("a11y/role-on-generic", { file, line: role.line, column: role.column, vars: { role: word, tag: record.name, element: ROLES.get(word) } }));
+      } else if (onclick !== void 0 && !has(record.attrs, "tabindex")) {
+        found.push(finding("a11y/role-on-generic:onclick", { file, line: onclick.line, column: onclick.column, vars: { attribute: "onclick", tag: record.name } }));
+      }
+    }
+    if (record.name === "a" && !has(record.attrs, "href")) {
+      const name = tokens.find((token) => world.info.get(token)?.hosts?.includes("a"));
+      if (name !== void 0) found.push(finding("a11y/link-no-href", { file, line: record.line, column: record.column, vars: { tag: "a", name } }));
+    }
+  }
+  return found;
+}
+
+// packages/check/src/rules/index.js
+var LUZ_FILE = /(?:^|[/@])luz[-.a-z]*\.(?:css|js)(?:[?#]|$)/i;
+var PREFIXED = /(?:^|[ \t\n\r\f])(?:luz|o|u)-/;
+function namesLuz(parsed) {
+  if (parsed.css !== null) return parsed.css.classes.some((entry) => entry.name.startsWith("luz-"));
+  for (const record of parsed.records) {
+    if (record.name.startsWith("luz-")) return true;
+    for (const [name, attribute] of record.attrs) {
+      if (name.startsWith("data-luz-")) return true;
+      if ((name === "class" || name === "classname") && PREFIXED.test(attribute.value)) return true;
+      if ((name === "href" || name === "src") && (attribute.value.includes("@luz-ds/") || LUZ_FILE.test(attribute.value))) return true;
+    }
+  }
+  return false;
+}
+function checkParsed(parsed, ctx) {
+  const base = { file: parsed.path, world: ctx.world, defined: ctx.defined, take: ctx.take };
+  if (parsed.css !== null) return stylesheetClasses({ ...base, css: parsed.css });
+  const markup = { ...base, records: parsed.records, template: parsed.kind === "template", doc: ctx.doc };
+  return [...unknownClasses(markup), ...elementRules(markup), ...loadRules(markup), ...misuseRules(markup)];
+}
+
+// packages/tokens/lib/theme.js
+var BASE_MODES = ["light", "dark", "high-contrast"];
+var stripComments = (css) => css.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "));
+function parseRules(css) {
+  const text = stripComments(css);
+  const rules = [];
+  let i = 0;
+  let line = 1;
+  function readPrelude() {
+    let depth = 0;
+    let quote = "";
+    let start = i;
+    let startLine = line;
+    while (i < text.length && /\s/.test(text[i])) {
+      if (text[i] === "\n") line++;
+      i++;
+    }
+    start = i;
+    startLine = line;
+    for (; i < text.length; i++) {
+      const c = text[i];
+      if (c === "\n") line++;
+      if (quote) {
+        if (c === "\\") i++;
+        else if (c === quote) quote = "";
+        continue;
+      }
+      if (c === '"' || c === "'") quote = c;
+      else if (c === "(" || c === "[") depth++;
+      else if (c === ")" || c === "]") depth--;
+      else if (depth <= 0 && (c === "{" || c === ";" || c === "}")) break;
+    }
+    return { prelude: text.slice(start, i).trim(), stop: text[i], line: startLine };
+  }
+  function readBlock(conditions, selectors, atLine) {
+    const declarations = [];
+    while (i < text.length) {
+      const { prelude, stop, line: startLine } = readPrelude();
+      if (stop === "{") {
+        i++;
+        if (prelude.startsWith("@")) {
+          readBlockInto(prelude, conditions, selectors);
+        } else {
+          const inner = readBlock(conditions, prelude.split(",").map((s) => s.trim()).filter(Boolean), startLine);
+          void inner;
+        }
+      } else {
+        const colon = prelude.indexOf(":");
+        if (prelude && !prelude.startsWith("@") && colon > 0) {
+          const name = prelude.slice(0, colon).trim();
+          if (name.startsWith("--luz-")) declarations.push({ name, value: prelude.slice(colon + 1).trim(), line: startLine });
+        }
+        if (stop === "}") {
+          i++;
+          break;
+        }
+        if (stop === ";") i++;
+        else break;
+      }
+    }
+    if (selectors && declarations.length) rules.push({ selectors, conditions, declarations, line: atLine });
+    return declarations;
+  }
+  function readBlockInto(atPrelude, conditions, selectors) {
+    readBlock([...conditions, atPrelude], selectors ?? null, line);
+  }
+  readBlock([], null, 1);
+  return rules;
+}
+function readSelector(selector) {
+  const compound = selector.trim().replace(/\s+/g, "");
+  let rest = compound;
+  let theme = null;
+  let mode = null;
+  let attrs = 0;
+  let types = 0;
+  if (/^html/i.test(rest)) {
+    rest = rest.slice(4);
+    types = 1;
+  } else if (rest.startsWith("*")) rest = rest.slice(1);
+  for (; ; ) {
+    if (rest.startsWith(":root")) {
+      rest = rest.slice(5);
+      attrs++;
+      continue;
+    }
+    const attr = rest.match(/^\[(data-theme|data-mode)=(?:"([\w-]+)"|'([\w-]+)'|([\w-]+))\]/);
+    if (attr) {
+      const value = attr[2] ?? attr[3] ?? attr[4];
+      if (attr[1] === "data-theme") theme = value;
+      else mode = value;
+      rest = rest.slice(attr[0].length);
+      attrs++;
+      continue;
+    }
+    break;
+  }
+  if (rest !== "") return null;
+  return { theme, mode, specificity: attrs * 100 + types };
+}
+var schemeOf = (prelude) => prelude.match(/^@media\s*\(\s*prefers-color-scheme\s*:\s*(light|dark)\s*\)$/i)?.[1].toLowerCase() ?? null;
+var transparent = (prelude) => /^@(layer|supports)\b/i.test(prelude);
+function targetsOf(rules) {
+  const themes = /* @__PURE__ */ new Set();
+  for (const { selectors } of rules) {
+    for (const s of selectors) {
+      const read = readSelector(s);
+      if (read?.theme && !BASE_MODES.includes(read.theme)) themes.add(read.theme);
+    }
+  }
+  const targets = BASE_MODES.map((name) => ({ name, theme: name, mode: null, scheme: name === "high-contrast" ? null : name }));
+  for (const theme of [...themes].sort()) {
+    targets.push({ name: theme, theme, mode: null, scheme: "light", custom: true });
+    for (const mode of BASE_MODES) targets.push({ name: `${theme}/${mode}`, theme, mode, scheme: mode === "high-contrast" ? null : mode, custom: true });
+  }
+  return targets;
+}
+function valuesFor(target, sources) {
+  const values = {};
+  const origin = {};
+  const rank = {};
+  const ignored = [];
+  let order2 = 0;
+  for (const { file, rules } of sources) {
+    for (const rule of rules) {
+      order2++;
+      let scheme = "any";
+      let skip = null;
+      for (const condition of rule.conditions) {
+        const wanted = schemeOf(condition);
+        if (wanted) scheme = wanted;
+        else if (!transparent(condition)) skip = condition;
+      }
+      if (skip) {
+        ignored.push({ file, line: rule.line, selector: rule.selectors.join(", "), reason: `${skip} is not evaluated` });
+        continue;
+      }
+      if (scheme !== "any" && scheme !== target.scheme) continue;
+      for (const selector of rule.selectors) {
+        const read = readSelector(selector);
+        if (!read) {
+          if (file !== "tokens") ignored.push({ file, line: rule.line, selector, reason: "only html, :root, [data-theme] and [data-mode] selectors are read" });
+          continue;
+        }
+        const themeOk = read.theme === null || read.theme === target.theme;
+        const modeOk = read.mode === null ? true : read.mode === target.mode;
+        if (!themeOk || !modeOk) continue;
+        for (const { name, value, line } of rule.declarations) {
+          const key = read.specificity * 1e6 + order2;
+          if (rank[name] !== void 0 && rank[name] > key) continue;
+          rank[name] = key;
+          values[name] = value;
+          origin[name] = { file, line };
+        }
+      }
+    }
+  }
+  return { values, origin, ignored };
+}
+
+// packages/tokens/lib/check.js
+function analyze(sources, { strict = false } = {}) {
+  const mine = sources.slice(1);
+  const targets = targetsOf(mine.flatMap((s) => s.rules));
+  const failures = [];
+  const warnings = [];
+  const unreadable = /* @__PURE__ */ new Map();
+  const ignored = /* @__PURE__ */ new Map();
+  let checked = 0;
+  const overridesOf = (tokens, values, origin) => [...new Set(tokens)].filter((t) => origin[t] && origin[t].file !== "tokens").map((t) => ({ token: t, value: values[t], file: origin[t].file, line: origin[t].line }));
+  for (const target of targets) {
+    const { values, origin, ignored: left } = valuesFor(target, sources);
+    for (const item of left) ignored.set(`${item.file}:${item.line} ${item.selector}`, item);
+    const { results, unreadable: bad } = measure(createResolver(values), pairsFor(target.name));
+    for (const r of results) {
+      checked++;
+      if (r.ok) continue;
+      (r.advisory && !strict ? warnings : failures).push({
+        mode: target.name,
+        foreground: r.foreground,
+        background: r.background,
+        ratio: Math.floor(r.ratio * 100) / 100,
+        minimum: r.minimum,
+        kind: r.kind,
+        overrides: overridesOf(r.tokens, values, origin)
+      });
+    }
+    for (const b of bad) {
+      unreadable.set(b.reason, { mode: target.name, foreground: b.foreground, background: b.background, reason: b.reason, overrides: overridesOf(b.tokens, values, origin) });
+    }
+  }
+  return {
+    ok: failures.length === 0 && unreadable.size === 0,
+    modes: targets.map((t) => t.name),
+    checked,
+    failures,
+    warnings,
+    unreadable: [...unreadable.values()],
+    ignored: [...ignored.values()]
+  };
+}
+
+// packages/check/src/rules/theme.js
+var MAX_THEMES = 16;
+var WIDE = /^@supports\b[\s\S]*(?:^|[\s(:])(?:oklch|oklab|lab|lch|hwb|color|color-mix|light-dark)\(/i;
+var REFERENCE = /^var\(--luz-[A-Za-z0-9-]{1,56}\)$/;
+function rulesOf(text) {
+  try {
+    return parseRules(text);
+  } catch {
+    return null;
+  }
+}
+function colourTokens(rules) {
+  const values = {};
+  for (const rule of rules) for (const { name, value } of rule.declarations) values[name] = value;
+  const resolve3 = createResolver(values);
+  const names = /* @__PURE__ */ new Set();
+  for (const name of Object.keys(values)) {
+    try {
+      parseColor(resolve3(name).value);
+      names.add(name);
+    } catch {
+    }
+  }
+  return names;
+}
+function readable(value) {
+  if (/^var\(/i.test(value)) return true;
+  try {
+    parseColor(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var echoValue = (value) => toHex(value) ?? (REFERENCE.test(value) ? value : null);
+var byText3 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function themeFindings({ files, named, linked, tokensFor }) {
+  const found = [];
+  const wanted = new Set(named);
+  const candidates = [];
+  for (const { path, text } of files) {
+    if (wanted.has(path) || text.includes("--luz-")) candidates.push({ path, text });
+  }
+  if (candidates.length === 0) return found;
+  let tokens = tokensFor(candidates[0].path);
+  let tokenRules = tokens === null ? null : rulesOf(tokens.text);
+  if ((tokenRules === null || tokenRules.length === 0) && tokens?.source === "node_modules") {
+    tokens = tokensFor(candidates[0].path, true);
+    tokenRules = tokens === null ? null : rulesOf(tokens.text);
+  }
+  if (tokenRules === null || tokenRules.length === 0) return found;
+  const colours = colourTokens(tokenRules);
+  const themes = [];
+  for (const { path, text } of candidates) {
+    const rules = rulesOf(text);
+    if (rules !== null && (wanted.has(path) || rules.some((rule) => rule.declarations.some((declaration) => colours.has(declaration.name))))) themes.push({ path, rules });
+  }
+  if (themes.length === 0) return found;
+  const given = /* @__PURE__ */ new Map();
+  named.forEach((path, index) => given.has(path) || given.set(path, index));
+  const link = /* @__PURE__ */ new Map();
+  linked.forEach((path, index) => link.has(path) || link.set(path, index));
+  const rest = themes.filter((theme) => !given.has(theme.path)).sort((a, b) => (link.get(a.path) ?? Infinity) - (link.get(b.path) ?? Infinity) || byText3(a.path, b.path));
+  const own = themes.filter((theme) => given.has(theme.path)).sort((a, b) => given.get(a.path) - given.get(b.path));
+  const ordered = [...rest, ...own];
+  const unlinked = rest.find((theme) => !link.has(theme.path));
+  if (rest.length > 1 && unlinked !== void 0) found.push(finding("theme/advisory", { file: unlinked.path, vars: { source: "alphabetical" } }));
+  const names = targetsOf(ordered.flatMap((theme) => theme.rules)).filter((target) => target.custom && target.mode === null);
+  const dropped = new Set(names.slice(MAX_THEMES).map((target) => target.theme));
+  let beyond = null;
+  const sources = ordered.map((theme) => {
+    const rules = [];
+    for (const rule of theme.rules) {
+      if (dropped.size > 0 && targetsOf([rule]).some((target) => target.custom && dropped.has(target.theme))) {
+        beyond ??= theme.path;
+        continue;
+      }
+      if (!rule.conditions.some((condition) => WIDE.test(condition))) {
+        rules.push(rule);
+        continue;
+      }
+      const kept = rule.declarations.filter((declaration) => readable(declaration.value));
+      for (const declaration of rule.declarations) {
+        if (!kept.includes(declaration)) found.push(finding("theme/advisory:wide", { file: theme.path, line: declaration.line, vars: { token: declaration.name } }));
+      }
+      if (kept.length > 0) rules.push({ ...rule, declarations: kept });
+    }
+    return { file: theme.path, rules };
+  });
+  if (beyond !== null) found.push(finding("theme/advisory:limit", { file: beyond, vars: { count: String(dropped.size), limit: String(MAX_THEMES) } }));
+  const result = analyze([{ file: "tokens", rules: tokenRules }, ...sources]);
+  const first = ordered[0].path;
+  const places = (list, withValue) => list.map((o) => {
+    const place = { token: echoName(o.token) };
+    if (withValue) place.value = echoValue(o.value);
+    place.file = displayPath(o.file);
+    place.line = o.line;
+    return place;
+  });
+  for (const failure of result.failures) {
+    const { mode, foreground, background, ratio: ratio2, minimum, kind, overrides } = failure;
+    const layers = background.split(/\s*>\s*/);
+    if (layers.length > 1 && layers[layers.length - 1] !== "surface-page") layers.push("surface-page");
+    found.push(
+      finding(layers.length > 1 ? "theme/contrast:layers" : "theme/contrast", {
+        file: overrides[0]?.file ?? first,
+        vars: { mode, foreground: layers.length > 1 ? foreground.slice(6) : foreground, background: layers.join("/"), ratio: formatRatio(ratio2).slice(0, -2), minimum: String(minimum), kind },
+        details: { mode: echoName(mode), foreground, background, ratio: ratio2, minimum, kind, overrides: places(overrides, true) }
+      })
+    );
+  }
+  for (const bad of result.unreadable) {
+    const { mode, foreground, background, overrides } = bad;
+    const last = overrides[overrides.length - 1];
+    found.push(
+      finding("theme/unreadable", {
+        file: last?.file ?? first,
+        vars: { token: last?.token ?? foreground },
+        details: { mode: echoName(mode), foreground, background, overrides: places(overrides, false) }
+      })
+    );
+  }
+  const placed = /* @__PURE__ */ new Map();
+  for (const theme of sources) {
+    const lines2 = /* @__PURE__ */ new Map();
+    for (const rule of theme.rules) lines2.set(rule.line, [...lines2.get(rule.line) ?? [], rule]);
+    placed.set(theme.file, lines2);
+  }
+  for (const item of result.ignored) {
+    for (const rule of placed.get(item.file)?.get(item.line) ?? []) {
+      if (!rule.selectors.includes(item.selector) && rule.selectors.join(", ") !== item.selector) continue;
+      const colour = rule.declarations.find((declaration) => colours.has(declaration.name));
+      if (colour !== void 0) found.push(finding("theme/advisory:unplaced", { file: item.file, line: item.line, vars: { token: colour.name } }));
+      break;
+    }
+  }
+  return found;
+}
+
+// packages/check/src/cli.js
+var BUNDLED_DATA = fileURLToPath(new URL("../dist/data/", import.meta.url));
+var BUNDLED_AGENT = fileURLToPath(new URL("../dist/agents/luz-accessibility-reviewer.md", import.meta.url));
+var NO_MANIFEST = "No LUZ manifest to read: the files name LUZ, and neither node_modules/@luz-ds nor the data bundled with luz-check has one; reinstall @luz-ds/check.";
+var STYLE_TAG = /<style\b/i;
+var USAGE = `Usage: luz-check [paths\u2026] [--json] [--strict] [--config <file>] [--theme <file.css>] [--ext .astro,.vue]
+       luz-check agent
+       luz-check --version | --help
+
+Reads the HTML and CSS you wrote and says which LUZ classes, elements, load
+order and theme colours are wrong. It runs offline and writes nothing. A path
+is a file, a folder (read recursively: .html, .htm and .css) or a glob such as
+"src/**/*.html"; with no path it reads the current folder.
+
+  --json           print the report as JSON
+  --strict         fail on a warning as well
+  --config <file>  read this configuration instead of luz-check.json
+  --theme <file>   a theme stylesheet (repeatable)
+  --ext <list>     also read these extensions as HTML, such as .astro,.vue
+  agent            print the accessibility reviewer
+  --version        print the version
+  --help           show this text
+
+Limits: 1 MiB a file, 128 MiB, 5 000 entries and 64 folders deep. It never
+follows a link; what it did not read is listed as skipped.
+
+Exit code 0 when nothing blocks, 1 when a finding blocks, 2 for a usage error or nothing to read.
+
+It reads source files only. It does not check names, labels, alt text,
+headings or the language of a page, and a run with no findings says nothing
+about them.`;
+var VALUE_OPTIONS = /* @__PURE__ */ new Set(["--config", "--theme", "--ext"]);
+var EXTENSION = /^\.?[A-Za-z0-9]{1,16}$/;
+var OPTION_HINT = "luz-check --help lists the options.";
+var shown = (value, max = 80) => displayPath([...String(value)].slice(0, max).join(""));
+var usageError = (text) => ({ code: 2, stdout: "", stderr: `${text}
+` });
+function parseArgs(args) {
+  const options = { help: false, version: false, json: false, strict: false, config: null, themes: [], ext: [], paths: [] };
+  let onlyPaths = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (onlyPaths || !arg.startsWith("-") || arg === "-") {
+      options.paths.push(arg);
+      continue;
+    }
+    if (arg === "--") onlyPaths = true;
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else if (arg === "--version" || arg === "-v") options.version = true;
+    else if (arg === "--json") options.json = true;
+    else if (arg === "--strict") options.strict = true;
+    else {
+      const equals = arg.indexOf("=");
+      const name = equals === -1 ? arg : arg.slice(0, equals);
+      if (!VALUE_OPTIONS.has(name)) return { error: `Unknown option ${shown(arg, 40)}; ${OPTION_HINT}` };
+      const value = equals === -1 ? args[++i] : arg.slice(equals + 1);
+      if (value === void 0 || value === "" || equals === -1 && value.startsWith("-")) return { error: `${name} needs a value; ${OPTION_HINT}` };
+      if (name === "--config") options.config = value;
+      else if (name === "--theme") options.themes.push(value);
+      else {
+        for (const part of value.split(",")) {
+          const extension = part.trim();
+          if (!EXTENSION.test(extension)) return { error: `--ext takes extensions such as .astro,.vue, not ${shown(extension, 20)}` };
+          options.ext.push(extension.startsWith(".") ? extension : `.${extension}`);
+        }
+      }
+    }
+  }
+  return options;
+}
+function parseFile(file) {
+  if (file.kind === "css") {
+    const css = readCss(file.text, file.path);
+    const errors2 = css.findings.map((problem) => ({ line: problem.line, column: problem.column, kind: "CSS" }));
+    return { path: file.path, kind: file.kind, text: file.text, css, records: [], errors: errors2 };
+  }
+  const records = [];
+  const errors = [];
+  for (const record of scan(file.text, file.path)) {
+    if (record.type === "error") {
+      errors.push({ line: record.line, column: record.column, kind: "HTML" });
+      break;
+    }
+    records.push(record);
+  }
+  return { path: file.path, kind: file.kind, text: file.text, css: null, records, errors };
+}
+function definedClasses(files) {
+  let names = null;
+  const build = () => {
+    names = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      if (file.kind === "css") {
+        for (const entry of readCss(file.text, file.path).classes) if (entry.defined) names.add(entry.name);
+      } else if (STYLE_TAG.test(file.text)) {
+        for (const record of scan(file.text, file.path)) {
+          if (record.type !== "element" || record.name !== "style" || !record.text) continue;
+          for (const entry of readCss(record.text, file.path).classes) if (entry.defined) names.add(entry.name);
+        }
+      }
+    }
+  };
+  return {
+    has(name) {
+      if (names === null) build();
+      return names.has(name);
+    }
+  };
+}
+function importsOfRun(files) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const file of files) if (file.kind === "css" && file.text.includes("@import")) imports.set(file.path, importsOf(file.text));
+  return imports;
+}
+function loadConfig(cwd, option) {
+  const wanted = option === null ? resolve2(cwd, "luz-check.json") : resolve2(cwd, option);
+  const name = displayPath(option === null ? "luz-check.json" : relative2(resolve2(cwd), wanted).split(sep2).join("/") || ".");
+  let stat;
+  try {
+    stat = lstatSync2(wanted);
+  } catch {
+    if (option === null) return { config: parseConfig("{}"), file: null };
+    throw new ConfigError(name, "was not found");
+  }
+  if (stat.isSymbolicLink()) throw new ConfigError(name, "is a link, which luz-check does not follow; name the file itself");
+  if (!stat.isFile()) throw new ConfigError(name, "is not a file");
+  const read = readLimited(wanted, 1 << 20);
+  if (read.reason) throw new ConfigError(name, read.reason === "too-large" ? "is larger than 64 kB" : "could not be read");
+  return { config: parseConfig(read.text, name), file: name };
+}
+function execute(argv, env) {
+  if (!Array.isArray(argv) || argv.some((arg) => typeof arg !== "string")) return usageError(`luz-check takes text arguments; ${OPTION_HINT}`);
+  if (argv.includes("--help") || argv.includes("-h")) return { code: 0, stdout: `${USAGE}
+`, stderr: "" };
+  const version2 = env && typeof env.version === "string" ? env.version : null;
+  if (argv.includes("--version") || argv.includes("-v")) {
+    if (version2 === null) return usageError("luz-check has no version here.");
+    return { code: 0, stdout: `@luz-ds/check ${cleanText(version2, 40)}
+`, stderr: "" };
+  }
+  const options = parseArgs(argv);
+  if ("error" in options) return usageError(options.error);
+  if (!env || typeof env.cwd !== "string" || version2 === null) return usageError("luz-check needs a working directory and a version.");
+  const { cwd } = env;
+  if (options.paths.length === 1 && options.paths[0] === "agent") {
+    let reviewer;
+    try {
+      reviewer = readFileSync(BUNDLED_AGENT, "utf-8");
+    } catch {
+      return usageError("luz-check agent could not read the reviewer file that ships with this package; reinstall @luz-ds/check.");
+    }
+    return { code: 0, stdout: reviewer, stderr: "" };
+  }
+  const { config, file: configFile } = loadConfig(cwd, options.config);
+  const strict = options.strict || config.strict;
+  const inputs = options.paths.length > 0 ? options.paths : ["."];
+  const extensions = [...new Set(options.ext)];
+  const read = collect(inputs, { cwd, ext: extensions, ignore: config.ignore });
+  if (read.missing.length > 0) {
+    const names = read.missing.map((input) => shown(input)).join(", ");
+    return usageError(`No file matches ${names}; luz-check reads .html, .htm and .css files and the extensions of --ext.`);
+  }
+  const themes = [...config.themes, ...options.themes];
+  for (const theme of themes) {
+    if (!theme.toLowerCase().endsWith(".css")) return usageError(`Theme ${shown(theme)} is not a .css file.`);
+  }
+  const themed = { files: [], skipped: [], missing: [] };
+  for (const theme of themes) {
+    const one = collect([theme], { cwd, ignore: [] });
+    themed.files.push(...one.files);
+    themed.skipped.push(...one.skipped);
+    themed.missing.push(...one.missing);
+  }
+  if (themed.missing.length > 0) return usageError(`No theme file ${themed.missing.map((input) => shown(input)).join(", ")}.`);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const file of [...read.files, ...themed.files]) if (!byPath.has(file.path)) byPath.set(file.path, file);
+  const skipped = [...read.skipped];
+  for (const entry of themed.skipped) if (!skipped.some((s) => s.file === entry.file)) skipped.push(entry);
+  const files = [...byPath.values()];
+  if (files.length === 0) {
+    const left = read.ignored > 0 ? ` (${read.ignored} left out by the ignore list)` : "";
+    return usageError(`No HTML or CSS file to read${left}; luz-check reads .html, .htm and .css files and the extensions of --ext.`);
+  }
+  const data = typeof env.data === "string" && env.data !== "" ? env.data : BUNDLED_DATA;
+  const facts = createFacts({ data });
+  const defined = definedClasses(files);
+  const imports = importsOfRun(files);
+  const startFile = createBudget();
+  const manifests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const findings = [];
+  let missing = false;
+  const worldOf = (directory) => {
+    const world = facts.forDirectory(directory);
+    if (world.packages.length === 0) {
+      missing = true;
+      return null;
+    }
+    for (const entry of world.packages) {
+      const key = `${entry.package} ${entry.version} ${entry.source}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        manifests.push(entry);
+      }
+    }
+    return world;
+  };
+  const linked = [];
+  const named = [];
+  let reached = false;
+  for (const file of files) {
+    const parsed = parseFile(file);
+    for (const error of parsed.errors) {
+      const key = file.kind === "template" ? "parse/error:template" : "parse/error";
+      findings.push(finding(key, { file: file.path, line: error.line, column: error.column, vars: { kind: error.kind } }));
+    }
+    const directory = dirname2(resolve2(cwd, file.path));
+    const take = startFile();
+    let doc = null;
+    if (file.kind === "css") {
+      reached = reached || reachesLuz(file.path, imports);
+      for (const found of cssRules({ file: file.path, css: parsed.css, text: file.text, world: () => worldOf(directory), take })) findings.push(found);
+      if (missing) return usageError(NO_MANIFEST);
+    } else {
+      doc = documentOf(parsed.records, file.path, imports);
+      reached = reached || doc.bundled || doc.dynamic || doc.inline || doc.entries.length > 0;
+      for (const record of parsed.records) {
+        const rel = record.name === "link" ? record.attrs.get("rel") : void 0;
+        const href = rel !== void 0 && STYLESHEET.test(rel.value) ? record.attrs.get("href") : void 0;
+        const target = href === void 0 ? null : runPath(file.path, href.value);
+        if (target !== null) linked.push(target);
+      }
+    }
+    if (!namesLuz(parsed)) continue;
+    if (doc !== null && doc.page && file.kind === "html" && parsed.errors.length === 0) named.push(file.path);
+    const world = worldOf(directory);
+    if (world === null) return usageError(NO_MANIFEST);
+    for (const found of checkParsed(parsed, { world, defined, take, doc })) findings.push(found);
+  }
+  const sheets = files.filter((file) => file.kind === "css");
+  if (sheets.length > 0) {
+    const given = [...new Set(themed.files.map((file) => file.path))];
+    for (const found of themeFindings({ files: sheets, named: given, linked, tokensFor: (path, bundled) => facts.tokensFor(dirname2(resolve2(cwd, path)), bundled) })) findings.push(found);
+  }
+  if (named.length > 0 && !reached) findings.push(finding("load/no-stylesheet", { file: named[0], vars: { count: String(named.length) } }));
+  const kept = findings.filter((found) => !(found.severity === "warn" && config.rules[found.rule] === "off"));
+  const order2 = new Map(PACKAGES.map((name, index) => [`@luz-ds/${name}`, index]));
+  manifests.sort((a, b) => order2.get(a.package) - order2.get(b.package));
+  const report = buildReport({
+    version: version2,
+    files: files.map((file) => file.path),
+    manifests,
+    findings: kept,
+    skipped,
+    config: { file: configFile, off: Object.keys(config.rules) },
+    ignored: read.ignored,
+    strict
+  });
+  return { code: report.ok ? 0 : 1, stdout: options.json ? formatJson(report) : formatText(report), stderr: "" };
+}
+function run(argv, env) {
+  try {
+    return execute(argv, env);
+  } catch (error) {
+    if (error instanceof ConfigError) return usageError(cleanText(error.message, 200));
+    return usageError("luz-check stopped on an internal error; no file was checked.");
+  }
+}
+
+// packages/check/src/main.js
+var manifest = fileURLToPath2(new URL("../package.json", import.meta.url));
+var { version } = JSON.parse(readFileSync2(manifest, "utf-8"));
+var { code, stdout, stderr } = run(process.argv.slice(2), { version, cwd: process.cwd() });
+if (stdout) process.stdout.write(stdout);
+if (stderr) process.stderr.write(stderr);
+process.exitCode = code;