@kbach/react 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/chunk-J2M6QWJW.mjs

@@ -0,0 +1,1385 @@
+import {
+  resolveKbachConfig
+} from "./chunk-4Y2QXNJY.mjs";
+import {
+  buildResetCSS,
+  defaultTheme
+} from "./chunk-EOSN5CYG.mjs";
+
+// src/vite-plugin/index.ts
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync, existsSync, statSync as statSync2 } from "fs";
+import { join as join4, dirname } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+
+// src/vite-plugin/cssVars.ts
+function hexToRgbTriplet(hex) {
+  const h = hex.replace("#", "");
+  const expand = (s) => s.length === 3 ? s.split("").map((c) => c + c).join("") : s;
+  const full = expand(h);
+  if (full.length !== 6) return null;
+  const r = parseInt(full.slice(0, 2), 16);
+  const g = parseInt(full.slice(2, 4), 16);
+  const b = parseInt(full.slice(4, 6), 16);
+  if ([r, g, b].some((n) => Number.isNaN(n))) return null;
+  return `${r},${g},${b}`;
+}
+function buildColorVarMap(theme, cssText) {
+  const replacements = /* @__PURE__ */ new Map();
+  const declarations = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(theme.colors)) {
+    if (typeof value !== "string") continue;
+    const varName = `--color-${name}`;
+    if (cssText.includes(value)) {
+      replacements.set(value, `var(${varName})`);
+      declarations.set(varName, value);
+    }
+    const triplet = hexToRgbTriplet(value);
+    if (!triplet) continue;
+    const rgbaPrefix = `rgba(${triplet},`;
+    if (cssText.includes(rgbaPrefix)) {
+      const rgbVarName = `--color-${name}-rgb`;
+      replacements.set(rgbaPrefix, `rgba(var(${rgbVarName}),`);
+      declarations.set(rgbVarName, triplet);
+    }
+  }
+  return { replacements, declarations };
+}
+var SPACING_PROPS = /* @__PURE__ */ new Set([
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "gap",
+  "column-gap",
+  "row-gap",
+  "width",
+  "height",
+  "min-width",
+  "min-height",
+  "max-width",
+  "max-height",
+  "top",
+  "right",
+  "bottom",
+  "left"
+]);
+function buildSpacingVarMap(theme, cssText) {
+  const replacements = /* @__PURE__ */ new Map();
+  const declarations = /* @__PURE__ */ new Map();
+  const pxToKey = /* @__PURE__ */ new Map();
+  for (const [key, val] of Object.entries(theme.spacing)) {
+    if (!pxToKey.has(val)) pxToKey.set(val, key);
+  }
+  const varNameFor = (key) => `--spacing-${key.replace(/\./g, "_")}`;
+  const declRe = /([a-z-]+): (\d+(?:\.\d+)?)px/g;
+  let m;
+  while ((m = declRe.exec(cssText)) !== null) {
+    const [, prop, numStr] = m;
+    if (!SPACING_PROPS.has(prop)) continue;
+    const key = pxToKey.get(parseFloat(numStr));
+    if (key === void 0) continue;
+    const varName = varNameFor(key);
+    replacements.set(`${prop}: ${numStr}px`, `${prop}: var(${varName})`);
+    declarations.set(varName, `${numStr}px`);
+  }
+  return { replacements, declarations };
+}
+function applyVarMap(cssText, ...maps) {
+  const replacements = /* @__PURE__ */ new Map();
+  const declarations = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [k, v] of map.replacements) replacements.set(k, v);
+    for (const [k, v] of map.declarations) declarations.set(k, v);
+  }
+  const sorted = [...replacements].sort(([a], [b]) => b.length - a.length);
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = sorted.map(([pattern, replacement]) => [new RegExp(escapeRegex(pattern), "g"), replacement]);
+  const text = cssText.replace(/\{([^{}]*)\}/g, (_whole, inner) => {
+    let replaced = inner;
+    for (const [re, replacement] of patterns) {
+      replaced = replaced.replace(re, () => replacement);
+    }
+    return `{${replaced}}`;
+  });
+  return { text, declarations };
+}
+
+// src/vite-plugin/mediaMerge.ts
+var RESPONSIVE_MEDIA_RE = /^@media \(min-width: (\d+)px\) \{ (.+) \}$/;
+function mergeResponsiveMediaBlocks(rules) {
+  const byWidth = /* @__PURE__ */ new Map();
+  const widthOrder = [];
+  const unwrapped = [];
+  for (const rule of rules) {
+    const m = RESPONSIVE_MEDIA_RE.exec(rule);
+    if (!m) {
+      unwrapped.push(rule);
+      continue;
+    }
+    const width = Number(m[1]);
+    if (!byWidth.has(width)) {
+      byWidth.set(width, []);
+      widthOrder.push(width);
+    }
+    byWidth.get(width).push(m[2]);
+  }
+  widthOrder.sort((a, b) => a - b);
+  const merged = widthOrder.map((w) => `@media (min-width: ${w}px) { ${byWidth.get(w).join(" ")} }`);
+  return [...unwrapped, ...merged];
+}
+
+// src/vite-plugin/prettify.ts
+function prettifyCSS(css) {
+  const out = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of css) {
+    if (ch === "{") {
+      const selector = current.trim();
+      if (selector) out.push(`${"  ".repeat(depth)}${selector} {`);
+      depth++;
+      current = "";
+    } else if (ch === "}") {
+      const decl = current.trim();
+      if (decl) out.push(`${"  ".repeat(depth)}${decl};`);
+      depth = Math.max(0, depth - 1);
+      out.push(`${"  ".repeat(depth)}}`);
+      current = "";
+    } else if (ch === ";") {
+      const decl = current.trim();
+      if (decl) out.push(`${"  ".repeat(depth)}${decl};`);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const trailing = current.trim();
+  if (trailing) out.push(trailing);
+  return out.join("\n");
+}
+
+// src/vite-plugin/format.ts
+var KBACH_START = "/* kbach:start */";
+var KBACH_END = "/* kbach:end */";
+function formatKbachCSS(tokenRules, theme, usedTags) {
+  const allEntries = [];
+  for (const rules of tokenRules.values()) {
+    for (const entry of rules) allEntries.push(entry);
+  }
+  allEntries.sort((a, b) => a.order - b.order);
+  const allRules = allEntries.map((e) => e.rule);
+  const merged = mergeResponsiveMediaBlocks(allRules);
+  const compact = merged.join("\n");
+  const colorMap = buildColorVarMap(theme, compact);
+  const spacingMap = buildSpacingVarMap(theme, compact);
+  const { text, declarations } = applyVarMap(compact, colorMap, spacingMap);
+  const lines = ["/* Generated by Kbach \u2014 do not edit */", "", buildResetCSS(usedTags)];
+  if (declarations.size > 0) {
+    lines.push("", ":root {");
+    for (const [varName, val] of declarations) lines.push(`  ${varName}: ${val};`);
+    lines.push("}");
+  }
+  lines.push("", prettifyCSS(text));
+  return lines.join("\n");
+}
+function writeKbachToFile(filePath, css, readFile, writeFile) {
+  let existing = "";
+  try {
+    existing = readFile(filePath);
+  } catch {
+  }
+  const block = `${KBACH_START}
+${css}
+${KBACH_END}`;
+  const start = existing.indexOf(KBACH_START);
+  const end = existing.indexOf(KBACH_END);
+  const next = start !== -1 && end !== -1 && end > start ? existing.slice(0, start) + block + existing.slice(end + KBACH_END.length) : existing ? `${existing}
+
+${block}` : block;
+  if (next === existing) return false;
+  writeFile(filePath, next);
+  return true;
+}
+
+// src/vite-plugin/classNameHints.ts
+var STRUCTURAL_TOKENS = [
+  // layout.rs
+  "flex",
+  "flex-row",
+  "flex-col",
+  "flex-row-reverse",
+  "flex-col-reverse",
+  "flex-wrap",
+  "flex-wrap-reverse",
+  "flex-nowrap",
+  "flex-1",
+  "flex-auto",
+  "flex-initial",
+  "flex-none",
+  "flex-grow",
+  "flex-grow-0",
+  "flex-shrink",
+  "flex-shrink-0",
+  "grow",
+  "grow-0",
+  "shrink",
+  "shrink-0",
+  "grid",
+  "block",
+  "inline-block",
+  "inline",
+  "inline-flex",
+  "inline-grid",
+  "contents",
+  "flow-root",
+  "hidden",
+  "items-center",
+  "items-start",
+  "items-end",
+  "items-baseline",
+  "items-stretch",
+  "justify-center",
+  "justify-start",
+  "justify-end",
+  "justify-between",
+  "justify-around",
+  "justify-evenly",
+  "content-start",
+  "content-end",
+  "content-center",
+  "content-between",
+  "content-around",
+  "content-evenly",
+  "content-stretch",
+  "self-auto",
+  "self-center",
+  "self-start",
+  "self-end",
+  "self-stretch",
+  "self-baseline",
+  "overflow-hidden",
+  "overflow-auto",
+  "overflow-scroll",
+  "overflow-visible",
+  "static",
+  "relative",
+  "absolute",
+  "fixed",
+  "sticky",
+  "aspect-square",
+  "aspect-video",
+  "w-full",
+  "h-full",
+  "min-w-full",
+  "max-w-full",
+  "min-h-full",
+  "max-h-full",
+  "w-screen",
+  "h-screen",
+  "min-w-screen",
+  "max-w-screen",
+  "min-h-screen",
+  "max-h-screen",
+  "w-auto",
+  "h-auto",
+  "m-auto",
+  "mx-auto",
+  "my-auto",
+  // grid.rs — web-only (see the module's own doc comment for why)
+  "grid-cols-none",
+  "grid-rows-none",
+  "grid-flow-row",
+  "grid-flow-col",
+  "grid-flow-dense",
+  "grid-flow-row-dense",
+  "grid-flow-col-dense",
+  "auto-cols-auto",
+  "auto-cols-min",
+  "auto-cols-max",
+  "auto-cols-fr",
+  "auto-rows-auto",
+  "auto-rows-min",
+  "auto-rows-max",
+  "auto-rows-fr",
+  "col-span-full",
+  "row-span-full",
+  "col-start-auto",
+  "col-end-auto",
+  "row-start-auto",
+  "row-end-auto",
+  "col",
+  "col-auto",
+  "row",
+  "row-auto",
+  "place-items-start",
+  "place-items-end",
+  "place-items-center",
+  "place-items-stretch",
+  "place-items-baseline",
+  "place-content-start",
+  "place-content-end",
+  "place-content-center",
+  "place-content-stretch",
+  "place-content-between",
+  "place-content-around",
+  "place-content-evenly",
+  "place-content-baseline",
+  "place-self-auto",
+  "place-self-start",
+  "place-self-end",
+  "place-self-center",
+  "place-self-stretch",
+  "justify-items-start",
+  "justify-items-end",
+  "justify-items-center",
+  "justify-items-stretch",
+  "justify-self-auto",
+  "justify-self-start",
+  "justify-self-end",
+  "justify-self-center",
+  "justify-self-stretch",
+  // transform.rs — web-only (see the module's own doc comment for why)
+  "transform-none",
+  "origin-center",
+  "origin-top",
+  "origin-top-right",
+  "origin-right",
+  "origin-bottom-right",
+  "origin-bottom",
+  "origin-bottom-left",
+  "origin-left",
+  "origin-top-left",
+  // filters.rs — web-only (see the module's own doc comment for why)
+  "blur",
+  "blur-sm",
+  "blur-md",
+  "blur-lg",
+  "blur-xl",
+  "blur-2xl",
+  "blur-3xl",
+  "blur-none",
+  "grayscale",
+  "grayscale-0",
+  "invert",
+  "invert-0",
+  "sepia",
+  "sepia-0",
+  "drop-shadow",
+  "drop-shadow-sm",
+  "drop-shadow-md",
+  "drop-shadow-lg",
+  "drop-shadow-xl",
+  "drop-shadow-2xl",
+  "drop-shadow-none",
+  "filter-none",
+  "backdrop-filter-none",
+  "backdrop-blur",
+  "backdrop-blur-sm",
+  "backdrop-blur-md",
+  "backdrop-blur-lg",
+  "backdrop-blur-xl",
+  "backdrop-blur-2xl",
+  "backdrop-blur-3xl",
+  "backdrop-blur-none",
+  "backdrop-grayscale",
+  "backdrop-grayscale-0",
+  "backdrop-invert",
+  "backdrop-invert-0",
+  "backdrop-sepia",
+  "backdrop-sepia-0",
+  // border.rs
+  "border",
+  "border-t",
+  "border-r",
+  "border-b",
+  "border-l",
+  "rounded",
+  "rounded-none",
+  "rounded-sm",
+  "rounded-md",
+  "rounded-lg",
+  "rounded-xl",
+  "rounded-2xl",
+  "rounded-3xl",
+  "rounded-full",
+  "ring",
+  "ring-0",
+  "ring-1",
+  "ring-2",
+  "ring-4",
+  "ring-8",
+  "ring-inset",
+  "ring-offset-0",
+  "ring-offset-1",
+  "ring-offset-2",
+  "ring-offset-4",
+  "ring-offset-8",
+  "outline",
+  "outline-none",
+  "border-solid",
+  "border-dashed",
+  "border-dotted",
+  "border-none",
+  // typography.rs
+  "font-thin",
+  "font-normal",
+  "font-medium",
+  "font-semibold",
+  "font-bold",
+  "font-extrabold",
+  "uppercase",
+  "lowercase",
+  "capitalize",
+  "underline",
+  "line-through",
+  "no-underline",
+  "truncate",
+  "text-xs",
+  "text-sm",
+  "text-base",
+  "text-lg",
+  "text-xl",
+  "text-2xl",
+  "text-3xl",
+  "text-4xl",
+  "text-left",
+  "text-center",
+  "text-right",
+  "text-justify",
+  // typography.rs — Phase 20 (typography completeness)
+  "italic",
+  "not-italic",
+  "leading-none",
+  "leading-tight",
+  "leading-snug",
+  "leading-normal",
+  "leading-relaxed",
+  "leading-loose",
+  "tracking-tighter",
+  "tracking-tight",
+  "tracking-normal",
+  "tracking-wide",
+  "tracking-wider",
+  "tracking-widest",
+  "decoration-auto",
+  "decoration-from-font",
+  "decoration-solid",
+  "decoration-dashed",
+  "decoration-dotted",
+  "decoration-double",
+  "decoration-wavy",
+  "underline-offset-auto",
+  "underline-offset-0",
+  "underline-offset-1",
+  "underline-offset-2",
+  "underline-offset-4",
+  "underline-offset-8",
+  "text-wrap",
+  "text-nowrap",
+  "text-balance",
+  "text-pretty",
+  "whitespace-normal",
+  "whitespace-nowrap",
+  "whitespace-pre",
+  "whitespace-pre-wrap",
+  "whitespace-pre-line",
+  "break-normal",
+  "break-words",
+  "break-all",
+  "align-baseline",
+  "align-top",
+  "align-middle",
+  "align-bottom",
+  "align-text-top",
+  "align-text-bottom",
+  "align-sub",
+  "align-super",
+  "list-none",
+  "list-disc",
+  "list-decimal",
+  "list-inside",
+  "list-outside",
+  "hyphens-none",
+  "hyphens-manual",
+  "hyphens-auto",
+  // effects.rs
+  "shadow",
+  "shadow-sm",
+  "shadow-md",
+  "shadow-lg",
+  "shadow-xl",
+  "shadow-2xl",
+  "shadow-inner",
+  "shadow-none",
+  "transition",
+  "transition-none",
+  "ease-linear",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "cursor-pointer",
+  "cursor-default",
+  "cursor-not-allowed",
+  "cursor-wait",
+  "select-none",
+  "select-text",
+  "select-all",
+  "pointer-events-none",
+  "pointer-events-auto",
+  // effects.rs — Phase 22 (effects completeness)
+  "text-shadow",
+  "text-shadow-sm",
+  "text-shadow-lg",
+  "text-shadow-none",
+  "mix-blend-normal",
+  "mix-blend-multiply",
+  "mix-blend-screen",
+  "mix-blend-overlay",
+  "mix-blend-darken",
+  "mix-blend-lighten",
+  "mix-blend-color-dodge",
+  "mix-blend-color-burn",
+  "mix-blend-hard-light",
+  "mix-blend-soft-light",
+  "mix-blend-difference",
+  "mix-blend-exclusion",
+  "mix-blend-hue",
+  "mix-blend-saturation",
+  "mix-blend-color",
+  "mix-blend-luminosity",
+  "mix-blend-plus-lighter",
+  "bg-blend-normal",
+  "bg-blend-multiply",
+  "bg-blend-screen",
+  "bg-blend-overlay",
+  "bg-blend-darken",
+  "bg-blend-lighten",
+  "bg-blend-color-dodge",
+  "bg-blend-color-burn",
+  "bg-blend-hard-light",
+  "bg-blend-soft-light",
+  "bg-blend-difference",
+  "bg-blend-exclusion",
+  "bg-blend-hue",
+  "bg-blend-saturation",
+  "bg-blend-color",
+  "bg-blend-luminosity",
+  "bg-blend-plus-lighter",
+  "animate-spin",
+  "animate-ping",
+  "animate-pulse",
+  "animate-bounce",
+  "animate-none",
+  // interactivity.rs — Phase 23 (interactivity & sizing rest)
+  "resize",
+  "resize-none",
+  "resize-y",
+  "resize-x",
+  "touch-auto",
+  "touch-none",
+  "touch-pan-x",
+  "touch-pan-left",
+  "touch-pan-right",
+  "touch-pan-y",
+  "touch-pan-up",
+  "touch-pan-down",
+  "touch-pinch-zoom",
+  "touch-manipulation",
+  "will-change-auto",
+  "will-change-scroll",
+  "will-change-contents",
+  "will-change-transform",
+  "sr-only",
+  "not-sr-only",
+  "border-collapse",
+  "border-separate",
+  "table-auto",
+  "table-fixed",
+  "caption-top",
+  "caption-bottom",
+  "stroke-width-0",
+  "stroke-width-1",
+  "stroke-width-2",
+  // spacing.rs — Phase 23 (size-* shorthand + fraction-based width/height)
+  "size-full",
+  "size-auto",
+  "size-px",
+  "w-1/2",
+  "w-1/3",
+  "w-2/3",
+  "w-1/4",
+  "w-2/4",
+  "w-3/4",
+  "w-1/5",
+  "w-2/5",
+  "w-3/5",
+  "w-4/5",
+  "w-1/6",
+  "w-5/6",
+  "w-1/12",
+  "w-5/12",
+  "w-7/12",
+  "w-11/12",
+  "h-1/2",
+  "h-1/3",
+  "h-2/3",
+  "h-1/4",
+  "h-2/4",
+  "h-3/4",
+  "h-1/5",
+  "h-2/5",
+  "h-3/5",
+  "h-4/5",
+  "h-1/6",
+  "h-5/6",
+  // scroll.rs — Phase 23 (scroll-behavior/-margin/-padding, scroll-snap)
+  "scroll-auto",
+  "scroll-smooth",
+  "snap-start",
+  "snap-end",
+  "snap-center",
+  "snap-align-none",
+  "snap-normal",
+  "snap-always",
+  "snap-none",
+  "snap-x",
+  "snap-y",
+  "snap-both",
+  "snap-mandatory",
+  "snap-proximity",
+  // divide.rs
+  "divide-x",
+  "divide-y",
+  // background.rs — web-only (see the module's own doc comment for why)
+  "bg-top",
+  "bg-bottom",
+  "bg-left",
+  "bg-right",
+  "bg-center",
+  "bg-left-top",
+  "bg-left-bottom",
+  "bg-right-top",
+  "bg-right-bottom",
+  "bg-auto",
+  "bg-cover",
+  "bg-contain",
+  "bg-repeat",
+  "bg-no-repeat",
+  "bg-repeat-x",
+  "bg-repeat-y",
+  "bg-repeat-round",
+  "bg-repeat-space",
+  "bg-fixed",
+  "bg-local",
+  "bg-scroll",
+  "bg-clip-border",
+  "bg-clip-padding",
+  "bg-clip-content",
+  "bg-clip-text",
+  "bg-origin-border",
+  "bg-origin-padding",
+  "bg-origin-content",
+  "bg-none",
+  "bg-linear-to-t",
+  "bg-linear-to-tr",
+  "bg-linear-to-r",
+  "bg-linear-to-br",
+  "bg-linear-to-b",
+  "bg-linear-to-bl",
+  "bg-linear-to-l",
+  "bg-linear-to-tl",
+  "bg-radial",
+  "bg-conic",
+  // Ancestor/sibling-state marker classes — carry no styles of their own,
+  // just a selector target for group-hover:/peer-hover:/etc. below (see
+  // unknownClassWarnings.ts's MARKER_CLASSES for why they need special
+  // handling there too).
+  "group",
+  "peer",
+  // registry.rs modifiers — bare tokens only, not composed with a
+  // following utility (see this module's doc header / the Phase 15 plan).
+  "hover:",
+  "focus:",
+  "focus-visible:",
+  "focus-within:",
+  "active:",
+  "visited:",
+  "disabled:",
+  "checked:",
+  "group-hover:",
+  "group-focus:",
+  "peer-hover:",
+  "peer-focus:",
+  "peer-checked:",
+  "dark:",
+  "motion-safe:",
+  "motion-reduce:",
+  "print:",
+  "sm:",
+  "md:",
+  "lg:",
+  "xl:",
+  "2xl:",
+  // registry.rs modifiers — Phase 24 (expanded variant system), the
+  // FIXED/static additions only. Deliberately excluded: every genuinely
+  // parameterized modifier (has-[...]/group-has-[...]/peer-has-[...]/
+  // data-[...]/aria-[...]/not-[...]/min-[...]/max-[...], and the
+  // generalized group-<pseudo>/peer-<pseudo> beyond the five hardcoded
+  // combos above) — these have no finite enumerable set (their whole point
+  // is arbitrary user-supplied content), so there's nothing meaningful to
+  // suggest beyond the bare prefix, same reasoning as every other
+  // arbitrary-value exclusion in this file. `not-hover:`/`not-disabled:`/
+  // etc. (wrapping a KNOWN static modifier) are excluded for the same
+  // reason — enumerable in principle, but a full cross-product with every
+  // modifier above would be more noise than signal for an editor hint list.
+  "first:",
+  "last:",
+  "only:",
+  "odd:",
+  "even:",
+  "open:",
+  "inert:",
+  "aria-checked:",
+  "aria-disabled:",
+  "aria-expanded:",
+  "aria-hidden:",
+  "aria-pressed:",
+  "aria-readonly:",
+  "aria-required:",
+  "aria-selected:",
+  "aria-busy:",
+  // registry.rs modifiers, added later — same "fixed/static, finite" bar
+  // as the Phase 24 block above. Structural -of-type/empty, form-state and
+  // validation pseudo-classes, other native pseudo-classes with no aria-*
+  // counterpart, a pseudo-element, pointer media variants, and the
+  // direct-children/all-descendants variants. "supports-[...]:"/"in-*:" are
+  // deliberately excluded here for the same "no finite enumerable set"
+  // reason as has-[...]:/group-<pseudo>: above.
+  "first-of-type:",
+  "last-of-type:",
+  "only-of-type:",
+  "empty:",
+  "enabled:",
+  "read-only:",
+  "required:",
+  "optional:",
+  "valid:",
+  "invalid:",
+  "in-range:",
+  "out-of-range:",
+  "default:",
+  "indeterminate:",
+  "placeholder-shown:",
+  "autofill:",
+  "user-valid:",
+  "user-invalid:",
+  "target:",
+  "fullscreen:",
+  "popover-open:",
+  "details-content:",
+  "pointer-coarse:",
+  "pointer-fine:",
+  "any-pointer-coarse:",
+  "any-pointer-fine:",
+  "*:",
+  "**:",
+  // Phase 25 (container queries & arbitrary properties). "@container" is a
+  // real UTILITY (container-type: inline-size), not a modifier — included
+  // as a bare token like "flex"/"hidden" above, not with the trailing ":"
+  // the modifier tokens below get. "@sm:"/"@md:"/"@lg:"/"@xl:"/"@2xl:" are
+  // container-responsive modifiers (registry.rs's `is_container_responsive`),
+  // and "starting:" wraps in @starting-style. Deliberately excluded, same
+  // "no finite enumerable set" reasoning as Phase 24's exclusions:
+  // "@min-[...]:"/"@max-[...]:" (arbitrary container breakpoints) and every
+  // `[property:value]` arbitrary property — both are open-ended by design.
+  "@container",
+  "@sm:",
+  "@md:",
+  "@lg:",
+  "@xl:",
+  "@2xl:",
+  "starting:"
+];
+var COLOR_PREFIXES = [
+  "bg-",
+  "text-",
+  "border-",
+  "divide-",
+  "decoration-",
+  "from-",
+  "via-",
+  "to-",
+  "text-shadow-",
+  "ring-",
+  "ring-offset-",
+  "caret-",
+  "accent-",
+  "fill-",
+  "stroke-"
+];
+var SPACING_PREFIXES = [
+  "p-",
+  "px-",
+  "py-",
+  "pt-",
+  "pr-",
+  "pb-",
+  "pl-",
+  "m-",
+  "mx-",
+  "my-",
+  "mt-",
+  "mr-",
+  "mb-",
+  "ml-",
+  "gap-",
+  "gap-x-",
+  "gap-y-",
+  "w-",
+  "h-",
+  "min-w-",
+  "max-w-",
+  "min-h-",
+  "max-h-",
+  "size-",
+  "top-",
+  "right-",
+  "bottom-",
+  "left-",
+  "inset-",
+  "space-x-",
+  "space-y-",
+  "indent-",
+  "scroll-m-",
+  "scroll-mx-",
+  "scroll-my-",
+  "scroll-mt-",
+  "scroll-mr-",
+  "scroll-mb-",
+  "scroll-ml-",
+  "scroll-p-",
+  "scroll-px-",
+  "scroll-py-",
+  "scroll-pt-",
+  "scroll-pr-",
+  "scroll-pb-",
+  "scroll-pl-"
+];
+var SIZE_PREFIXES = ["w-", "h-", "min-w-", "max-w-", "min-h-", "max-h-", "size-"];
+var NAMED_SIZES = ["sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "7xl", "8xl", "9xl"];
+function buildClassTokens(theme) {
+  const tokens = new Set(STRUCTURAL_TOKENS);
+  for (const colorKey of Object.keys(theme.colors)) {
+    for (const prefix of COLOR_PREFIXES) tokens.add(`${prefix}${colorKey}`);
+  }
+  for (const spacingKey of Object.keys(theme.spacing)) {
+    for (const prefix of SPACING_PREFIXES) tokens.add(`${prefix}${spacingKey}`);
+  }
+  for (const size of NAMED_SIZES) {
+    for (const prefix of SIZE_PREFIXES) tokens.add(`${prefix}${size}`);
+  }
+  return Array.from(tokens).sort();
+}
+function buildClassNameHintsDts(tokens) {
+  const literals = tokens.map((t) => `  | '${t}'`).join("\n");
+  return [
+    "// Generated by Kbach \u2014 do not edit",
+    "// Editor autocomplete for className \u2014 see packages/react/src/vite-plugin/classNameHints.ts",
+    "",
+    "type KbachClassToken =",
+    literals,
+    ";",
+    "",
+    "export type KbachClassName = KbachClassToken | `${string} ${KbachClassToken}` | (string & {});",
+    "",
+    "declare module 'react' {",
+    "  interface HTMLAttributes<T> {",
+    "    className?: KbachClassName | undefined;",
+    "  }",
+    "  interface SVGAttributes<T> {",
+    "    className?: KbachClassName | undefined;",
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+}
+
+// src/staticCss/engine.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/vite-plugin/wasmNode.ts
+import { generate_css } from "@kbach/core-engine/node";
+function generateCssForToken(token, themeJson) {
+  return JSON.parse(generate_css(token, themeJson));
+}
+
+// src/vite-plugin/scan.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function stripComments(code) {
+  let out = "";
+  let i = 0;
+  const n = code.length;
+  while (i < n) {
+    const two = code[i] + (code[i + 1] ?? "");
+    if (two === "//") {
+      i += 2;
+      while (i < n && code[i] !== "\n") i++;
+      continue;
+    }
+    if (two === "/*") {
+      i += 2;
+      while (i < n && code[i] + (code[i + 1] ?? "") !== "*/") i++;
+      i += 2;
+      continue;
+    }
+    const ch = code[i];
+    if (ch === '"' || ch === "'") {
+      out += ch;
+      i++;
+      while (i < n && code[i] !== ch) {
+        if (code[i] === "\\") {
+          out += code[i] + (code[i + 1] ?? "");
+          i += 2;
+          continue;
+        }
+        out += code[i];
+        i++;
+      }
+      out += code[i] ?? "";
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      out += ch;
+      i++;
+      let interpolationDepth = 0;
+      while (i < n) {
+        if (interpolationDepth === 0 && code[i] === "`") {
+          out += code[i];
+          i++;
+          break;
+        }
+        if (interpolationDepth === 0 && code[i] === "\\") {
+          out += code[i] + (code[i + 1] ?? "");
+          i += 2;
+          continue;
+        }
+        if (interpolationDepth === 0 && code[i] + (code[i + 1] ?? "") === "${") {
+          out += "${";
+          i += 2;
+          interpolationDepth = 1;
+          continue;
+        }
+        if (interpolationDepth > 0) {
+          if (code[i] === "{") interpolationDepth++;
+          else if (code[i] === "}") {
+            interpolationDepth--;
+            if (interpolationDepth === 0) {
+              out += "}";
+              i++;
+              continue;
+            }
+          }
+        }
+        out += code[i];
+        i++;
+      }
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function splitClassTokens(str) {
+  return str.split(/\s+/).filter(Boolean);
+}
+var NOT_A_CLASS_NAME_RE = /[${}]|-$|^[?:&|!"'=<>]+$/;
+function pushTokens(str, into) {
+  for (const tok of splitClassTokens(str)) {
+    if (tok && !NOT_A_CLASS_NAME_RE.test(tok)) into.add(tok);
+  }
+}
+function pushTemplateLiteralBody(body, into) {
+  const interpolationRe = /\$\{(?:[^{}]|\{[^{}]*\})*\}/g;
+  let im;
+  while ((im = interpolationRe.exec(body)) !== null) {
+    pushClassLikeStrings(im[0], into);
+  }
+  pushTokens(body.replace(/\$\{(?:[^{}]|\{[^{}]*\})*\}/g, () => "$"), into);
+}
+function pushClassLikeStrings(text, into) {
+  const quotedStringRe = /(["'`])((?:(?!\1).)*)\1/g;
+  let qm;
+  while ((qm = quotedStringRe.exec(text)) !== null) {
+    const [, quote, content] = qm;
+    if (quote === "`") pushTemplateLiteralBody(content, into);
+    else pushTokens(content, into);
+  }
+}
+var JSX_TAG_RE = /<([a-z][a-zA-Z0-9]*)[\s/>]/g;
+function scanUsedTags(code) {
+  const cleaned = stripComments(code);
+  const tags = /* @__PURE__ */ new Set();
+  let m;
+  JSX_TAG_RE.lastIndex = 0;
+  while ((m = JSX_TAG_RE.exec(cleaned)) !== null) tags.add(m[1]);
+  return tags;
+}
+function extractClassStrings(rawCode) {
+  const code = stripComments(rawCode);
+  const found = /* @__PURE__ */ new Set();
+  const simpleRe = /(?:className|kb)=(["'])((?:(?!\1).)*)\1/g;
+  let m;
+  while ((m = simpleRe.exec(code)) !== null) pushTokens(m[2], found);
+  const jsxExprRe = /(?:className|kb)=\{/g;
+  while ((m = jsxExprRe.exec(code)) !== null) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    let block = "";
+    while (i < code.length && depth > 0) {
+      const ch = code[i];
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        if (--depth === 0) break;
+      }
+      block += ch;
+      i++;
+    }
+    jsxExprRe.lastIndex = i + 1;
+    pushClassLikeStrings(block, found);
+  }
+  const classComposerCallRe = /(?:clsx|cn|classnames|cx|kb)\(/g;
+  while ((m = classComposerCallRe.exec(code)) !== null) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    let block = "";
+    while (i < code.length && depth > 0) {
+      const ch = code[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        if (--depth === 0) break;
+      }
+      block += ch;
+      i++;
+    }
+    classComposerCallRe.lastIndex = i + 1;
+    pushClassLikeStrings(block, found);
+  }
+  const templateRe = /`([^`]{1,2000})`/g;
+  while ((m = templateRe.exec(code)) !== null) pushTemplateLiteralBody(m[1], found);
+  return [...found];
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", ".next", ".output", ".git", ".svn", ".cache", "coverage"]);
+var MAX_SCAN_DEPTH = 10;
+var DEFAULT_FILE_MATCH = /\.(tsx?|jsx?)$/;
+function scanDir(dir, onFile, depth = 0, fileMatch = DEFAULT_FILE_MATCH) {
+  if (depth > MAX_SCAN_DEPTH) return;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".") || SKIP_DIRS.has(entry)) continue;
+    const full = join(dir, entry);
+    try {
+      const st = statSync(full);
+      if (st.isDirectory()) scanDir(full, onFile, depth + 1, fileMatch);
+      else if (fileMatch.test(entry)) onFile(full, readFileSync(full, "utf-8"));
+    } catch {
+    }
+  }
+}
+
+// src/vite-plugin/unknownClassWarnings.ts
+import { join as join2 } from "path";
+var CSS_CLASS_SELECTOR_RE = /\.(-?[a-zA-Z_][a-zA-Z0-9_-]*)/g;
+var CSS_FILE_RE = /\.(css|scss|sass|less)$/;
+var useColor = !!process.stdout?.isTTY && !process.env.NO_COLOR;
+var paint = (code, s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var green = (s) => paint("32", s);
+var blue = (s) => paint("34", s);
+var white = (s) => paint("97", s);
+var gray = (s) => paint("90", s);
+var bold = (s) => paint("1", s);
+var ARROW = () => green("\u2192");
+var TAG = () => bold(green("[kbach]"));
+var highlight = (s) => bold(white(s));
+function findLineCol(code, needle) {
+  const index = code.indexOf(needle);
+  if (index === -1) return null;
+  let line = 1;
+  let lastNewline = -1;
+  for (let i = 0; i < index; i++) {
+    if (code.charCodeAt(i) === 10) {
+      line++;
+      lastNewline = i;
+    }
+  }
+  return { line, column: index - lastNewline };
+}
+function scanCssFileInto(code, into) {
+  const re = new RegExp(CSS_CLASS_SELECTOR_RE.source, "g");
+  let m;
+  while ((m = re.exec(code)) !== null) into.add(m[1]);
+}
+function scanProjectCssSelectors(root, includeDirs) {
+  const projectCssClasses = /* @__PURE__ */ new Set();
+  for (const dir of includeDirs) {
+    scanDir(join2(root, dir), (_filePath, code) => scanCssFileInto(code, projectCssClasses), 0, CSS_FILE_RE);
+  }
+  return projectCssClasses;
+}
+function stripModifierPrefix(token) {
+  return token.replace(/^(?:[a-zA-Z0-9_/-]+:)+/, "");
+}
+var MARKER_CLASSES = /* @__PURE__ */ new Set(["group", "peer"]);
+function warnIfUnknownClass(token, filePath, code, isResolvable, projectCssClasses, warnedTokens) {
+  if (isResolvable || warnedTokens.has(token)) return;
+  const base = stripModifierPrefix(token);
+  if (!base || projectCssClasses.has(base) || MARKER_CLASSES.has(base)) return;
+  warnedTokens.add(token);
+  const pos = findLineCol(code, token);
+  const location = pos ? `${blue(filePath)}${green(`:${pos.line}:${pos.column}`)}` : blue(filePath);
+  console.warn(
+    `${ARROW()} ${TAG()} ${gray("Unknown class")} ${highlight(token)} ${gray("\u2014 no Kbach utility or project CSS rule matches it. Typo?")}
+  ${bold("at")} ${location}`
+  );
+}
+
+// src/staticCss/engine.ts
+function normPath(p) {
+  const fwd = p.replace(/\\/g, "/");
+  return process.platform === "win32" ? fwd.toLowerCase() : fwd;
+}
+var SAFELIST_KEY = "\0kbach-safelist";
+function createKbachStaticCssEngine(options) {
+  const { root, theme, themeJson, includeDirs, safelist } = options;
+  const fileTokens = /* @__PURE__ */ new Map();
+  const tokenRules = /* @__PURE__ */ new Map();
+  const fileTags = /* @__PURE__ */ new Map();
+  let projectCssClasses = /* @__PURE__ */ new Set();
+  const warnedTokens = /* @__PURE__ */ new Set();
+  function resolveToken(tok) {
+    if (!tokenRules.has(tok)) {
+      tokenRules.set(tok, generateCssForToken(tok, themeJson).rules);
+    }
+    return tokenRules.get(tok);
+  }
+  function processFile(filePath, code) {
+    const tokens = /* @__PURE__ */ new Set();
+    for (const tok of extractClassStrings(code)) {
+      tokens.add(tok);
+      const rules = resolveToken(tok);
+      if (process.env.NODE_ENV !== "production") {
+        warnIfUnknownClass(tok, filePath, code, rules.length > 0, projectCssClasses, warnedTokens);
+      }
+    }
+    fileTokens.set(normPath(filePath), tokens);
+    fileTags.set(normPath(filePath), scanUsedTags(code));
+  }
+  function removeFile(filePath) {
+    fileTokens.delete(normPath(filePath));
+    fileTags.delete(normPath(filePath));
+  }
+  function processSafelist() {
+    if (safelist.length === 0) return;
+    const tokens = new Set(safelist);
+    for (const tok of tokens) resolveToken(tok);
+    fileTokens.set(SAFELIST_KEY, tokens);
+  }
+  function activeTokens() {
+    const active = /* @__PURE__ */ new Set();
+    for (const tokens of fileTokens.values()) for (const t of tokens) active.add(t);
+    return active;
+  }
+  function activeTags() {
+    const active = /* @__PURE__ */ new Set();
+    for (const tags of fileTags.values()) for (const t of tags) active.add(t);
+    return active;
+  }
+  function generateCSS() {
+    const active = activeTokens();
+    const view = /* @__PURE__ */ new Map();
+    for (const tok of active) {
+      const rules = tokenRules.get(tok);
+      if (rules) view.set(tok, rules);
+    }
+    for (const tok of tokenRules.keys()) {
+      if (!active.has(tok)) tokenRules.delete(tok);
+    }
+    return formatKbachCSS(view, theme, activeTags());
+  }
+  function initialScan() {
+    for (const dir of includeDirs) {
+      scanDir(join3(root, dir), processFile);
+    }
+  }
+  function scanProjectCssSelectorsOnce() {
+    projectCssClasses = scanProjectCssSelectors(root, includeDirs);
+  }
+  return { processFile, removeFile, initialScan, processSafelist, generateCSS, scanProjectCssSelectorsOnce };
+}
+function readSourceFile(path) {
+  return readFileSync2(path, "utf-8");
+}
+
+// src/vite-plugin/index.ts
+function findMainCSSFile(root, includeDirs, explicitCssFile) {
+  if (explicitCssFile) return join4(root, explicitCssFile);
+  const searchDirs = [...includeDirs, "."];
+  for (const dir of searchDirs) {
+    const candidate = join4(root, dir, "kbach.css");
+    if (!existsSync(candidate)) continue;
+    try {
+      const content = readFileSync3(candidate, "utf-8");
+      if (content.includes(KBACH_START) && content.includes(KBACH_END)) return candidate;
+    } catch {
+    }
+  }
+  for (const dir of includeDirs) {
+    const full = join4(root, dir);
+    try {
+      if (statSync2(full).isDirectory()) return join4(full, "kbach.css");
+    } catch {
+    }
+  }
+  return join4(root, includeDirs[0] ?? "src", "kbach.css");
+}
+var DEFAULT_SCAN_DIRS = ["src", "app", "pages", "components"];
+var CSS_SYNC_DEBOUNCE_MS = 50;
+function writeFileEnsuringDir(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf-8");
+}
+function isEsmRequireFailure(err) {
+  if (!(err instanceof Error)) return false;
+  return err.code === "ERR_REQUIRE_ESM" || /is not defined in ES module scope/.test(err.message);
+}
+async function importConfigModule(path) {
+  const mod = await import(pathToFileURL(path).href);
+  return mod.default ?? mod;
+}
+function requireConfigModule(root, path) {
+  const mod = createRequire(root)(path);
+  return mod.default ?? mod;
+}
+async function loadConfigFile(root) {
+  const cjsPath = join4(root, "kbach.config.cjs");
+  if (existsSync(cjsPath)) return requireConfigModule(root, cjsPath);
+  const mjsPath = join4(root, "kbach.config.mjs");
+  if (existsSync(mjsPath)) return importConfigModule(mjsPath);
+  const jsPath = join4(root, "kbach.config.js");
+  if (!existsSync(jsPath)) return void 0;
+  try {
+    return requireConfigModule(root, jsPath);
+  } catch (err) {
+    if (!isEsmRequireFailure(err)) throw err;
+    return importConfigModule(jsPath);
+  }
+}
+async function resolveEffectiveTheme(root, options) {
+  if (options.theme) return options.theme;
+  if (options.config) return resolveKbachConfig(options.config);
+  const discovered = await loadConfigFile(root);
+  return discovered ? resolveKbachConfig(discovered) : defaultTheme;
+}
+function kbach(options = {}) {
+  const includeDirs = options.include ?? DEFAULT_SCAN_DIRS;
+  const safelist = options.safelist ?? [];
+  let root = process.cwd();
+  let theme = defaultTheme;
+  let engine = createKbachStaticCssEngine({ root, theme, themeJson: JSON.stringify(theme), includeDirs, safelist });
+  let mainCSSFilePath = join4(root, "src", "kbach.css");
+  function mainCSSFile() {
+    return mainCSSFilePath;
+  }
+  function classNameHintsFile() {
+    return join4(root, ".kbach", "kbach-classnames.d.ts");
+  }
+  function writeClassNameHints() {
+    const dts = buildClassNameHintsDts(buildClassTokens(theme));
+    writeFileEnsuringDir(classNameHintsFile(), dts);
+  }
+  function syncMainCSSFile(server) {
+    const changed = writeKbachToFile(mainCSSFile(), engine.generateCSS(), readSourceFile, writeFileEnsuringDir);
+    if (changed && server) server.watcher.emit("change", mainCSSFile());
+  }
+  let syncTimer = null;
+  function scheduleSync(server) {
+    if (syncTimer) clearTimeout(syncTimer);
+    syncTimer = setTimeout(() => {
+      syncTimer = null;
+      syncMainCSSFile(server);
+    }, CSS_SYNC_DEBOUNCE_MS);
+  }
+  return {
+    name: "kbach",
+    enforce: "pre",
+    async configResolved(resolved) {
+      root = resolved.root;
+      theme = await resolveEffectiveTheme(root, options);
+      engine = createKbachStaticCssEngine({ root, theme, themeJson: JSON.stringify(theme), includeDirs, safelist });
+      mainCSSFilePath = findMainCSSFile(root, includeDirs, options.cssFile);
+    },
+    buildStart() {
+      engine.scanProjectCssSelectorsOnce();
+      engine.initialScan();
+      engine.processSafelist();
+      writeKbachToFile(mainCSSFile(), engine.generateCSS(), readSourceFile, writeFileEnsuringDir);
+      writeClassNameHints();
+    },
+    // handleHotUpdate covers edits; add/unlink (create/delete) land on the
+    // raw watcher instead — Vite's handleHotUpdate hook only fires for
+    // type === "update".
+    configureServer(server) {
+      const onAddOrUnlink = (file, isUnlink) => {
+        if (file.includes("node_modules")) return;
+        if (!/\.(tsx?|jsx?)$/.test(file)) return;
+        if (isUnlink) {
+          engine.removeFile(file);
+        } else {
+          try {
+            engine.processFile(file, readSourceFile(file));
+          } catch {
+            engine.removeFile(file);
+          }
+        }
+        scheduleSync(server);
+      };
+      server.watcher.on("add", (file) => onAddOrUnlink(file, false));
+      server.watcher.on("unlink", (file) => onAddOrUnlink(file, true));
+    },
+    handleHotUpdate({ file, server }) {
+      if (file.includes("node_modules")) return;
+      if (!/\.(tsx?|jsx?)$/.test(file)) return;
+      try {
+        engine.processFile(file, readSourceFile(file));
+      } catch {
+        engine.removeFile(file);
+      }
+      scheduleSync(server);
+    }
+  };
+}
+
+export {
+  createKbachStaticCssEngine,
+  findMainCSSFile,
+  DEFAULT_SCAN_DIRS,
+  CSS_SYNC_DEBOUNCE_MS,
+  loadConfigFile,
+  resolveEffectiveTheme,
+  kbach
+};