rainbowindex 0.6.0 → 0.7.0

package/dist/{chunk-KSNYSR3C.mjs → chunk-FJOZJIKB.mjs}

@@ -1,12 +1,20 @@
 import {
-  BORDER_DIR_PROPS,
-  BUILTIN_STATIC_KEYS,
-  COLOR_FUNCTION_ALTERNATION,
   CORNER_SHAPE_KEYWORDS,
   DEFAULT_COLORS,
   DEFAULT_CORNER_SCALE,
   DEFAULT_DARK_CONFIG,
   DEFAULT_SUPERELLIPSE_SCALE,
+  checkPaletteContrast,
+  generateAllColorVariables,
+  generateThemeOverrides,
+  isValidColorSuffix
+} from "./chunk-L56IRO7A.mjs";
+import {
+  BACKDROP_FILTER_COMPOSED,
+  BORDER_DIR_PROPS,
+  BUILTIN_STATIC_KEYS,
+  COLOR_FUNCTION_ALTERNATION,
+  FILTER_COMPOSED,
   GAP_MAP,
   INSET_MAP,
   IS_DEV,
@@ -23,13 +31,12 @@ import {
   devWarn,
   isFontFamilyValue,
   isMaskRadialSizeValue,
-  isValidColorSuffix,
   registerColorNames,
   registerCustomFontFamilies,
   registerCustomTextSizes,
   registerCustomUtility,
   snapshotCompilationContext
-} from "./chunk-6U4IOFOS.mjs";
+} from "./chunk-XQGSG2HK.mjs";
 
 // src/shared.ts
 function isRIDebug() {
@@ -130,6 +137,7 @@ var PARSER_ONLY_STATICS = [
   "h-max",
   "h-fit",
   "min-w-0",
+  "min-w-auto",
   "min-w-full",
   "min-w-min",
   "min-w-max",
@@ -141,6 +149,7 @@ var PARSER_ONLY_STATICS = [
   "max-w-fit",
   "max-w-prose",
   "min-h-0",
+  "min-h-auto",
   "min-h-full",
   "min-h-screen",
   "min-h-min",
@@ -508,18 +517,16 @@ function findVariantColon(input) {
   for (let i = 0; i < input.length; i++) {
     const ch = input[i];
     if (ch === "\\" && i + 1 < input.length) {
-      const next = input[i + 1];
-      if (isHexDigit(next)) {
-        let hexLen = 0;
-        while (hexLen < 6 && i + 1 + hexLen < input.length && isHexDigit(input[i + 1 + hexLen]))
-          hexLen++;
-        i += hexLen;
-        if (i + 1 < input.length && /\s/.test(input[i + 1])) i++;
-      } else {
-        i++;
-      }
+      i = endOfEscape(input, i);
       continue;
     }
+    if (depth > 0 && (ch === "'" || ch === '"')) {
+      const close = endOfQuoted(input, i);
+      if (close !== -1) {
+        i = close;
+        continue;
+      }
+    }
     if (ch === "[" || ch === "(") depth++;
     else if (ch === "]" || ch === ")") depth--;
     else if (ch === ":" && depth === 0) {
@@ -530,17 +537,74 @@ function findVariantColon(input) {
   }
   return -1;
 }
+function endOfEscape(s, i) {
+  if (i + 1 >= s.length) return i;
+  if (!isHexDigit(s[i + 1])) return i + 1;
+  let hexLen = 0;
+  while (hexLen < 6 && i + 1 + hexLen < s.length && isHexDigit(s[i + 1 + hexLen])) hexLen++;
+  let end = i + hexLen;
+  if (end + 1 < s.length && /\s/.test(s[end + 1])) end++;
+  return end;
+}
+function endOfQuoted(s, i) {
+  const quote = s[i];
+  for (let j = i + 1; j < s.length; j++) {
+    if (s[j] === "\\" && j + 1 < s.length) {
+      j++;
+      continue;
+    }
+    if (s[j] === quote) return j;
+  }
+  return -1;
+}
+function findVariantBracketEnd(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "\\") {
+      i = endOfEscape(s, i);
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      const close = endOfQuoted(s, i);
+      if (close !== -1) i = close;
+      continue;
+    }
+    if (ch === "[") depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
 function isHexDigit(ch) {
   const c = ch.charCodeAt(0);
   return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
 }
-var VARIANT_PREFIX_RE = /^[a-z0-9][a-z0-9-]*(\[[^\]]*\])?$/;
+var VARIANT_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+var VARIANT_MODIFIER_RE = /^\/[a-zA-Z0-9_-]+$/;
 function isVariantPrefix(s) {
   if (!s) return false;
   if (s.startsWith("[") && s.endsWith("]")) return true;
   if (s.startsWith("@")) return true;
   if (s === "*" || s === "**") return true;
-  return VARIANT_PREFIX_RE.test(s);
+  let name = s;
+  let tail = "";
+  const bracketStart = s.indexOf("[");
+  if (bracketStart !== -1) {
+    const bracketEnd = findVariantBracketEnd(s, bracketStart);
+    if (bracketEnd === -1) return false;
+    name = s.slice(0, bracketStart);
+    tail = s.slice(bracketEnd + 1);
+  } else {
+    const slash = s.indexOf("/");
+    if (slash !== -1) {
+      name = s.slice(0, slash);
+      tail = s.slice(slash);
+    }
+  }
+  return VARIANT_NAME_RE.test(name) && (tail === "" || VARIANT_MODIFIER_RE.test(tail));
 }
 function findMatchingBracket(input, start) {
   let depth = 0;
@@ -682,6 +746,53 @@ function diagnosticFromWarning(message, span) {
   };
 }
 
+// src/css/escape.ts
+function escapeSelector(raw) {
+  let out = null;
+  let runStart = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const code = raw.charCodeAt(i);
+    if (code >= 97 && code <= 122 || // a-z
+    code >= 65 && code <= 90 || // A-Z
+    code === 45 || // -
+    code === 95 || // _
+    code >= 128) {
+      continue;
+    }
+    if (code >= 48 && code <= 57 && // 0-9
+    i !== 0 && !(i === 1 && raw.charCodeAt(0) === 45)) {
+      continue;
+    }
+    let escaped;
+    if (code === 0) {
+      escaped = "\uFFFD";
+    } else if (code >= 48 && code <= 57) {
+      escaped = `\\${code.toString(16)} `;
+    } else if (code === 9 || code === 10 || code === 12 || code === 13) {
+      escaped = `\\${raw[i]}`;
+    } else if (code < 32 || code === 127) {
+      escaped = `\\${code.toString(16)} `;
+    } else {
+      escaped = `\\${raw[i]}`;
+    }
+    if (out === null) out = [];
+    out.push(raw.slice(runStart, i), escaped);
+    runStart = i + 1;
+  }
+  if (out === null) return raw;
+  out.push(raw.slice(runStart));
+  return out.join("");
+}
+
+// src/utilities/markers.ts
+var RELATIONAL_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+var MARKER_ROOTS = /* @__PURE__ */ new Set(["group", "peer"]);
+function isMarkerUtility(utility) {
+  const slash = utility.indexOf("/");
+  if (slash === -1) return MARKER_ROOTS.has(utility);
+  return MARKER_ROOTS.has(utility.slice(0, slash)) && RELATIONAL_NAME_RE.test(utility.slice(slash + 1));
+}
+
 // src/engine/variants.ts
 var MAX_CUSTOM_VARIANT_SELECTOR_LENGTH = 500;
 var SAFE_CSS_LENGTH_RE = /^\d+(\.\d+)?(px|em|rem|ch|vw|vh|svw|svh|dvw|dvh|cqw|cqh)$/;
@@ -814,10 +925,49 @@ function sanitizeVariantBracket(inner) {
   return cleaned;
 }
 var SAFE_AT_RULE_RE = /^@(?:media|supports|container|layer)\b/;
-function resolveRelationalVariant(inner, anchor, combinator) {
+function splitRelationalName(rest, kind) {
+  let depth = 0;
+  for (let i = rest.length - 1; i >= 0; i--) {
+    const ch = rest[i];
+    if (ch === "]" || ch === ")") depth++;
+    else if (ch === "[" || ch === "(") depth--;
+    else if (ch === "/" && depth === 0) {
+      const name = rest.slice(i + 1);
+      if (!RELATIONAL_NAME_RE.test(name)) return { state: rest, anchor: null };
+      return { state: rest.slice(0, i), anchor: `.${escapeSelector(`${kind}/${name}`)}` };
+    }
+  }
+  return { state: rest, anchor: `.${kind}` };
+}
+function breakpointValue(name, theme) {
+  if (!Object.hasOwn(theme.breakpoints, name)) return null;
+  const value = theme.breakpoints[name];
+  return SAFE_CSS_LENGTH_RE.test(value) ? value : null;
+}
+function widthBound(rest, theme) {
+  if (rest.startsWith("[") && rest.endsWith("]")) {
+    const v = rest.slice(1, -1);
+    return SAFE_CSS_LENGTH_RE.test(v) ? v : null;
+  }
+  return breakpointValue(rest, theme);
+}
+var MAX_VARIANT_NESTING = 6;
+function plainSelectorOf(w) {
+  if (!w?.selectorSuffix) return null;
+  if (w.replaceAmpersand || w.atRule || w.startingStyle || w.alternate) return null;
+  return w.selectorSuffix;
+}
+function resolveRelationalVariant(inner, anchor, combinator, resolveInner) {
   if (inner.startsWith("[") && inner.endsWith("]")) {
     const sel = sanitizeVariantBracket(inner.slice(1, -1));
-    return sel ? { selectorSuffix: `${anchor}:is(${sel})${combinator}`, replaceAmpersand: true } : null;
+    if (!sel) return null;
+    if (sel.includes("&")) {
+      return {
+        selectorSuffix: `${sel.replaceAll("&", anchor)}${combinator}`,
+        replaceAmpersand: true
+      };
+    }
+    return { selectorSuffix: `${anchor}:is(${sel})${combinator}`, replaceAmpersand: true };
   }
   if (Object.hasOwn(PSEUDO_CLASSES, inner)) {
     return {
@@ -825,6 +975,10 @@ function resolveRelationalVariant(inner, anchor, combinator) {
       replaceAmpersand: true
     };
   }
+  const nested = plainSelectorOf(resolveInner(inner));
+  if (nested !== null) {
+    return { selectorSuffix: `${anchor}${nested}${combinator}`, replaceAmpersand: true };
+  }
   return void 0;
 }
 var ATTR_NAME_RE = /^[a-z][a-z0-9-]*$/i;
@@ -905,6 +1059,26 @@ function listVariants(theme) {
   out.push(...VARIANT_PATTERNS);
   return out;
 }
+function appearanceVariant(variant, strategy) {
+  const media = MEDIA_VARIANTS[variant].wrapper;
+  if (strategy.kind === "media") return media;
+  if (strategy.kind === "selector") {
+    const sel = strategy.selector;
+    return Object.freeze(
+      variant === "dark" ? { selectorSuffix: `:where(${sel}, ${sel} *) &`, replaceAmpersand: true } : { selectorSuffix: `:where(:not(${sel}, ${sel} *)) &`, replaceAmpersand: true }
+    );
+  }
+  const overridden = variant === "dark" ? "light" : "dark";
+  return Object.freeze({
+    selectorSuffix: `:where(html[data-appearance="${variant}"]) &`,
+    replaceAmpersand: true,
+    alternate: Object.freeze({
+      selectorSuffix: `:where(html:not([data-appearance="${overridden}"])) &`,
+      replaceAmpersand: true,
+      atRule: media.atRule
+    })
+  });
+}
 function resolveVariant(variant, theme, customVariantMap, memo) {
   if (!memo) return resolveVariantUncached(variant, theme, customVariantMap);
   const cached = memo.get(variant);
@@ -913,72 +1087,91 @@ function resolveVariant(variant, theme, customVariantMap, memo) {
   memo.set(variant, wrapper);
   return wrapper;
 }
-function resolveVariantUncached(variant, theme, customVariantMap) {
+function resolveVariantUncached(variant, theme, customVariantMap, depth = 0) {
+  const inner = (v) => depth >= MAX_VARIANT_NESTING ? null : resolveVariantUncached(v, theme, customVariantMap, depth + 1);
   if (variant.startsWith("[") && variant.endsWith("]")) {
     return resolveArbitraryVariant(variant);
   }
-  if (Object.hasOwn(theme.breakpoints, variant)) {
-    const bp = theme.breakpoints[variant];
-    if (!SAFE_CSS_LENGTH_RE.test(bp)) return null;
-    return { atRule: `@media (min-width: ${bp})` };
+  {
+    const bp = breakpointValue(variant, theme);
+    if (bp !== null) return { atRule: `@media (min-width: ${bp})` };
   }
-  if (variant.startsWith("min-[") && variant.endsWith("]")) {
-    const v = variant.slice(5, -1);
-    return SAFE_CSS_LENGTH_RE.test(v) ? { atRule: `@media (width >= ${v})` } : null;
+  if (variant.startsWith("min-")) {
+    const v = widthBound(variant.slice(4), theme);
+    if (v !== null) return { atRule: `@media (width >= ${v})` };
   }
-  if (variant.startsWith("max-[") && variant.endsWith("]")) {
-    const v = variant.slice(5, -1);
-    return SAFE_CSS_LENGTH_RE.test(v) ? { atRule: `@media (width < ${v})` } : null;
+  if (variant.startsWith("max-")) {
+    const v = widthBound(variant.slice(4), theme);
+    if (v !== null) return { atRule: `@media (width < ${v})` };
   }
   if (variant.startsWith("@")) {
     const rest = variant.slice(1);
     const slashIdx = rest.indexOf("/");
-    if (slashIdx !== -1) {
-      const containerName = rest.slice(0, slashIdx);
-      const bp = rest.slice(slashIdx + 1);
-      if (Object.hasOwn(theme.breakpoints, bp) && CSS_CUSTOM_IDENT_RE.test(containerName)) {
-        const bpVal = theme.breakpoints[bp];
-        if (!SAFE_CSS_LENGTH_RE.test(bpVal)) return null;
-        return { atRule: `@container ${containerName} (min-width: ${bpVal})` };
+    const named = slashIdx !== -1 && CSS_CUSTOM_IDENT_RE.test(rest.slice(0, slashIdx));
+    if (slashIdx === -1 || named) {
+      const scope = named ? `${rest.slice(0, slashIdx)} ` : "";
+      const size = slashIdx === -1 ? rest : rest.slice(slashIdx + 1);
+      const bp = breakpointValue(size, theme);
+      if (bp !== null) return { atRule: `@container ${scope}(min-width: ${bp})` };
+      if (size.startsWith("min-")) {
+        const v = breakpointValue(size.slice(4), theme);
+        if (v !== null) return { atRule: `@container ${scope}(width >= ${v})` };
+      }
+      if (size.startsWith("max-")) {
+        const v = breakpointValue(size.slice(4), theme);
+        if (v !== null) return { atRule: `@container ${scope}(width < ${v})` };
       }
-    }
-    if (Object.hasOwn(theme.breakpoints, rest)) {
-      const bpVal = theme.breakpoints[rest];
-      if (!SAFE_CSS_LENGTH_RE.test(bpVal)) return null;
-      return { atRule: `@container (min-width: ${bpVal})` };
     }
   }
   if (Object.hasOwn(PSEUDO_CLASS_WRAPPERS, variant)) {
     return PSEUDO_CLASS_WRAPPERS[variant];
   }
   if (variant.startsWith("group-")) {
-    const r = resolveRelationalVariant(variant.slice(6), ".group", " &");
+    const { state, anchor } = splitRelationalName(variant.slice(6), "group");
+    if (anchor === null) return null;
+    const r = resolveRelationalVariant(state, anchor, " &", inner);
     if (r !== void 0) return r;
   }
   if (variant.startsWith("peer-")) {
-    const r = resolveRelationalVariant(variant.slice(5), ".peer", " ~ &");
+    const { state, anchor } = splitRelationalName(variant.slice(5), "peer");
+    if (anchor === null) return null;
+    const r = resolveRelationalVariant(state, anchor, " ~ &", inner);
     if (r !== void 0) return r;
   }
   if (variant.startsWith("in-[") && variant.endsWith("]")) {
     const sel = sanitizeVariantBracket(variant.slice(4, -1));
-    return sel ? { selectorSuffix: `:where(${sel}) &`, replaceAmpersand: true } : null;
+    return sel && !sel.includes("&") ? { selectorSuffix: `:where(${sel}) &`, replaceAmpersand: true } : null;
+  }
+  if (variant.startsWith("in-")) {
+    const nested = plainSelectorOf(inner(variant.slice(3)));
+    if (nested !== null) {
+      return { selectorSuffix: `:where(*${nested}) &`, replaceAmpersand: true };
+    }
   }
   if (Object.hasOwn(PSEUDO_ELEMENT_WRAPPERS, variant)) {
     return PSEUDO_ELEMENT_WRAPPERS[variant];
   }
+  if (variant === "dark" || variant === "light") {
+    return appearanceVariant(variant, theme.darkConfig.variant);
+  }
   if (Object.hasOwn(MEDIA_VARIANTS, variant)) return MEDIA_VARIANTS[variant].wrapper;
   if (Object.hasOwn(SPECIAL_SELECTORS, variant)) return SPECIAL_SELECTORS[variant].wrapper;
   if (variant.startsWith("supports-[") && variant.endsWith("]")) {
-    const inner = decodeArbitraryValue(variant.slice(10, -1));
-    if (!inner || inner.length > MAX_CUSTOM_VARIANT_SELECTOR_LENGTH || /[{}]/.test(inner))
+    const inner2 = decodeArbitraryValue(variant.slice(10, -1));
+    if (!inner2 || inner2.length > MAX_CUSTOM_VARIANT_SELECTOR_LENGTH || /[{}]/.test(inner2))
       return null;
-    return { atRule: `@supports ${inner.startsWith("(") ? inner : `(${inner})`}` };
+    return { atRule: `@supports ${inner2.startsWith("(") ? inner2 : `(${inner2})`}` };
   }
   for (const [prefix, fn] of NTH_VARIANTS) {
     if (variant.startsWith(prefix) && variant.endsWith("]")) {
       const arg = variant.slice(prefix.length, -1).trim();
       return /^(odd|even|[-+\dn\s]+)$/i.test(arg) ? { selectorSuffix: `:${fn}(${arg})` } : null;
     }
+    const bare = prefix.slice(0, -1);
+    if (variant.startsWith(bare)) {
+      const arg = variant.slice(bare.length);
+      if (/^\d+$/.test(arg)) return { selectorSuffix: `:${fn}(${arg})` };
+    }
   }
   if (variant.startsWith("data-")) {
     const r = resolveAttributeVariant(variant, "data", "");
@@ -989,17 +1182,34 @@ function resolveVariantUncached(variant, theme, customVariantMap) {
     if (r !== void 0) return r;
   }
   if (variant.startsWith("has-[") && variant.endsWith("]")) {
-    const inner = sanitizeVariantBracket(variant.slice(5, -1));
-    if (inner) return { selectorSuffix: `:has(${inner})` };
+    const sel = sanitizeVariantBracket(variant.slice(5, -1));
+    if (sel && !sel.includes("&")) return { selectorSuffix: `:has(${sel})` };
+  }
+  if (variant.startsWith("has-")) {
+    const nested = plainSelectorOf(inner(variant.slice(4)));
+    if (nested !== null) return { selectorSuffix: `:has(${nested})` };
   }
   if (variant.startsWith("not-")) {
-    const inner = variant.slice(4);
-    if (inner.startsWith("[") && inner.endsWith("]")) {
-      const sel = sanitizeVariantBracket(inner.slice(1, -1));
-      if (sel) return { selectorSuffix: `:not(${sel})` };
-    }
-    if (Object.hasOwn(PSEUDO_CLASSES, inner)) {
-      return { selectorSuffix: `:not(${PSEUDO_CLASSES[inner].suffix})` };
+    const rest = variant.slice(4);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      const sel = sanitizeVariantBracket(rest.slice(1, -1));
+      if (sel && !sel.includes("&")) return { selectorSuffix: `:not(${sel})` };
+    }
+    if (Object.hasOwn(PSEUDO_CLASSES, rest)) {
+      return { selectorSuffix: `:not(${PSEUDO_CLASSES[rest].suffix})` };
+    }
+    const nestedWrapper = inner(rest);
+    const nested = plainSelectorOf(nestedWrapper);
+    if (nested !== null) return { selectorSuffix: `:not(${nested})` };
+    const atRule = nestedWrapper?.atRule;
+    if (atRule && !nestedWrapper.selectorSuffix && !nestedWrapper.alternate) {
+      const spaceIdx = atRule.indexOf(" ");
+      if (spaceIdx !== -1) {
+        const name = atRule.slice(0, spaceIdx);
+        if (name === "@media" || name === "@supports") {
+          return { atRule: `${name} not ${atRule.slice(spaceIdx + 1)}` };
+        }
+      }
     }
   }
   const cv = customVariantMap?.get(variant);
@@ -1038,24 +1248,31 @@ function splitSelectorList(selector) {
   results.push(selector.slice(start).trim());
   return results.filter(Boolean);
 }
+var MEDIA_WORLD = 1;
+function applyOneWrapper(applied, w) {
+  let selector = applied.selector;
+  if (w.selectorSuffix) {
+    const branches = splitSelectorList(selector);
+    const suffix = w.selectorSuffix;
+    selector = w.replaceAmpersand ? branches.map((b) => suffix.replace(/&/g, b)).join(", ") : branches.map((b) => b + suffix).join(", ");
+  }
+  return {
+    selector,
+    atRules: w.atRule ? [...applied.atRules, w.atRule] : applied.atRules,
+    startingStyle: applied.startingStyle || w.startingStyle === true
+  };
+}
 function applyVariantWrappers(baseSelector, wrappers) {
-  let selector = baseSelector;
-  const atRules = [];
-  let startingStyle = false;
-  for (const w of wrappers) {
-    if (w.selectorSuffix) {
-      const branches = splitSelectorList(selector);
-      const suffix = w.selectorSuffix;
-      selector = w.replaceAmpersand ? branches.map((b) => suffix.replace(/&/g, b)).join(", ") : branches.map((b) => b + suffix).join(", ");
-    }
-    if (w.atRule) {
-      atRules.push(w.atRule);
-    }
-    if (w.startingStyle) {
-      startingStyle = true;
+  const worlds = wrappers.some((w) => w.alternate) ? 2 : 1;
+  const out = [];
+  for (let world = 0; world < worlds; world++) {
+    let branch = { selector: baseSelector, atRules: [], startingStyle: false };
+    for (const w of wrappers) {
+      branch = applyOneWrapper(branch, world === MEDIA_WORLD ? w.alternate ?? w : w);
     }
+    out.push(branch);
   }
-  return { selector, atRules, startingStyle };
+  return out;
 }
 
 // src/engine/suggest.ts
@@ -1114,47 +1331,10 @@ function findClosest(input, candidates, maxDistance) {
   return best;
 }
 
-// src/css/escape.ts
-function escapeSelector(raw) {
-  let out = null;
-  let runStart = 0;
-  for (let i = 0; i < raw.length; i++) {
-    const code = raw.charCodeAt(i);
-    if (code >= 97 && code <= 122 || // a-z
-    code >= 65 && code <= 90 || // A-Z
-    code === 45 || // -
-    code === 95 || // _
-    code >= 128) {
-      continue;
-    }
-    if (code >= 48 && code <= 57 && // 0-9
-    i !== 0 && !(i === 1 && raw.charCodeAt(0) === 45)) {
-      continue;
-    }
-    let escaped;
-    if (code === 0) {
-      escaped = "\uFFFD";
-    } else if (code >= 48 && code <= 57) {
-      escaped = `\\${code.toString(16)} `;
-    } else if (code === 9 || code === 10 || code === 12 || code === 13) {
-      escaped = `\\${raw[i]}`;
-    } else if (code < 32 || code === 127) {
-      escaped = `\\${code.toString(16)} `;
-    } else {
-      escaped = `\\${raw[i]}`;
-    }
-    if (out === null) out = [];
-    out.push(raw.slice(runStart, i), escaped);
-    runStart = i + 1;
-  }
-  if (out === null) return raw;
-  out.push(raw.slice(runStart));
-  return out.join("");
-}
-
 // src/css/token-refs.ts
-var COLOR_STOP_REF_RE = /var\(--color-([a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*)(?:-(\d+))?\)/g;
-var SHADOW_VAR_REF_RE = /var\(--shadow-([a-z0-9]+(?:-[a-z0-9]+)*)\)/g;
+var COLOR_STOP_REF_RE = /var\(--color-([a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*)(?:-(\d+))?\s*[,)]/g;
+var COLOR_VAR_REF_RE = /var\(--color-([\w-]+)\s*[,)]/g;
+var SHADOW_VAR_REF_RE = /var\(--shadow-(DEFAULT|[a-z0-9]+(?:-[a-z0-9]+)*)\)/g;
 var TEXT_VAR_REF_RE = /var\(--text-([a-z0-9]+(?:-[a-z0-9]+)*?)(?:-leading)?\)/g;
 var FONT_VAR_REF_RE = /var\(--font-([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\)/g;
 var ANIMATE_VAR_REF_RE = /var\(--animate-([a-z0-9]+(?:-[a-z0-9]+)*)\)/g;
@@ -1179,9 +1359,37 @@ function multi(...pairs) {
     declarations: pairs.map(([property, value]) => ({ property, value }))
   };
 }
+function hasBalancedDelimiters(value) {
+  const open = [];
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === "\\") {
+      i++;
+    } else if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < value.length && value[i] !== quote) {
+        if (value[i] === "\\") i++;
+        i++;
+      }
+      if (i >= value.length) return false;
+    } else if (ch === "(" || ch === "[") {
+      open.push(ch);
+    } else if (ch === ")") {
+      if (open.pop() !== "(") return false;
+    } else if (ch === "]") {
+      if (open.pop() !== "[") return false;
+    }
+  }
+  return open.length === 0;
+}
 function extractArbitrary(value) {
   if (!value) return null;
-  return value.startsWith("[") && value.endsWith("]") ? decodeArbitraryValue(value.slice(1, -1)) : null;
+  if (!value.startsWith("[") || !value.endsWith("]")) return null;
+  const inner = value.slice(1, -1);
+  if (inner === "") return null;
+  const decoded = decodeArbitraryValue(inner);
+  return hasBalancedDelimiters(decoded) ? decoded : null;
 }
 function normalizeDecimalToken(value) {
   return value.replaceAll("_", ".");
@@ -1196,6 +1404,44 @@ function spacingLookup(value, negative = false) {
   const expr = `calc(${normalized} * var(--spacing))`;
   return negative ? `calc(${normalized} * var(--spacing) * -1)` : expr;
 }
+var FRACTIONAL = Object.freeze({
+  "1/2": "50%",
+  "1/3": "33.333333%",
+  "2/3": "66.666667%",
+  "1/4": "25%",
+  "2/4": "50%",
+  "3/4": "75%",
+  "1/5": "20%",
+  "2/5": "40%",
+  "3/5": "60%",
+  "4/5": "80%",
+  "1/6": "16.666667%",
+  "2/6": "33.333333%",
+  "3/6": "50%",
+  "4/6": "66.666667%",
+  "5/6": "83.333333%",
+  "1/12": "8.333333%",
+  "2/12": "16.666667%",
+  "3/12": "25%",
+  "4/12": "33.333333%",
+  "5/12": "41.666667%",
+  "6/12": "50%",
+  "7/12": "58.333333%",
+  "8/12": "66.666667%",
+  "9/12": "75%",
+  "10/12": "83.333333%",
+  "11/12": "91.666667%"
+});
+function fractionValue(name) {
+  if (Object.hasOwn(FRACTIONAL, name)) return FRACTIONAL[name];
+  const slash = name.indexOf("/");
+  if (slash === -1) return null;
+  const numerator = name.slice(0, slash);
+  const denominator = name.slice(slash + 1);
+  if (!INTEGER_RE.test(numerator) || !INTEGER_RE.test(denominator)) return null;
+  if (Number(denominator) === 0) return null;
+  return `calc(${numerator} / ${denominator} * 100%)`;
+}
 function deepFreezeUtilityMap(map) {
   for (const value of Object.values(map)) {
     Object.freeze(value.declarations);
@@ -1452,6 +1698,35 @@ var DIRECTIVE_TYPE_NAMES = [
   "register"
 ];
 var REMOVAL_KEY = "--ri-rm";
+function legacySyntaxWarning(legacy, canonical, directiveName) {
+  const where = directiveName ? ` in @${directiveName}` : "";
+  return `[RI-1046] \`${legacy}\`${where} is a deprecated spelling \u2014 write \`${canonical}\` instead. The old form is not valid CSS, so a formatter cannot read the file; it still works, and will be removed at 1.0.`;
+}
+function hasTopLevelKeyframes(body) {
+  let depth = 0;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < body.length && body[i] !== quote) {
+        if (body[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") depth = Math.max(0, depth - 1);
+    else if (ch === "@" && depth === 0 && body.startsWith("@keyframes", i)) {
+      const after = body[i + "@keyframes".length];
+      if (after === void 0 || !/[\w-]/.test(after)) return true;
+    }
+  }
+  return false;
+}
+function isRemovalValue(value) {
+  return value === "initial";
+}
 var IDENT_KEY_RE = /^[\w-]+$/;
 var WS_CHAR_RE = /\s/;
 function topLevelIndexOf(str, char) {
@@ -1484,7 +1759,9 @@ function* scanEntries(src, opts) {
       let end = i + 1;
       while (end < src.length && /[\w-]/.test(src[end])) end++;
       const name = src.slice(i + 1, end);
-      if (name) yield { key: name, value: "", removal: true, start: i, end };
+      if (name) {
+        yield { key: name, value: "", removal: true, legacyRemoval: true, start: i, end };
+      }
       i = end;
       continue;
     }
@@ -1544,6 +1821,10 @@ function* scanEntries(src, opts) {
         if (value) yield { key: value, value: "", removal: true, start: entryStart, end: i };
         continue;
       }
+      if (isRemovalValue(value)) {
+        yield { key, value: "", removal: true, start: entryStart, end: i };
+        continue;
+      }
       yield { key, value, block, start: entryStart, end: i };
       continue;
     }
@@ -1556,6 +1837,10 @@ function* scanEntries(src, opts) {
       if (value) yield { key: value, value: "", removal: true, start: entryStart, end: i };
       continue;
     }
+    if (isRemovalValue(value)) {
+      yield { key, value: "", removal: true, start: entryStart, end: i };
+      continue;
+    }
     yield { key, value, start: entryStart, end: i };
   }
 }
@@ -1567,7 +1852,9 @@ function parseKeyValueBody(body, warnings, directiveName) {
     const line = raw.trim();
     if (!line) return;
     if (line.startsWith("!")) {
-      removals.push(line.slice(1).trim());
+      const name = line.slice(1).trim();
+      removals.push(name);
+      warnings?.push(legacySyntaxWarning(`!${name};`, `${name}: initial;`, directiveName));
       return;
     }
     const colonIdx = line.indexOf(":");
@@ -1578,6 +1865,10 @@ function parseKeyValueBody(body, warnings, directiveName) {
       removals.push(value);
       return;
     }
+    if (key && isRemovalValue(value)) {
+      removals.push(key);
+      return;
+    }
     if (key && !IDENT_KEY_RE.test(key)) {
       warnings?.push(
         `[RI-1035] Invalid @${directiveName ?? "directive"} entry key "${key}" \u2014 keys may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
@@ -1911,42 +2202,17 @@ var VIEWPORT_SIZES = Object.freeze({
   lvh: "100lvh",
   dvh: "100dvh"
 });
-var FRACTIONAL = Object.freeze({
-  "1/2": "50%",
-  "1/3": "33.333333%",
-  "2/3": "66.666667%",
-  "1/4": "25%",
-  "2/4": "50%",
-  "3/4": "75%",
-  "1/5": "20%",
-  "2/5": "40%",
-  "3/5": "60%",
-  "4/5": "80%",
-  "1/6": "16.666667%",
-  "2/6": "33.333333%",
-  "3/6": "50%",
-  "4/6": "66.666667%",
-  "5/6": "83.333333%",
-  "1/12": "8.333333%",
-  "2/12": "16.666667%",
-  "3/12": "25%",
-  "4/12": "33.333333%",
-  "5/12": "41.666667%",
-  "6/12": "50%",
-  "7/12": "58.333333%",
-  "8/12": "66.666667%",
-  "9/12": "75%",
-  "10/12": "83.333333%",
-  "11/12": "91.666667%"
-});
 function resolveSizeValue(val, named, negative) {
   const arb = extractArbitrary(val);
   if (arb !== null) return negative ? `calc(${arb} * -1)` : arb;
   if (Object.hasOwn(named, val)) return named[val];
-  if (Object.hasOwn(FRACTIONAL, val)) return FRACTIONAL[val];
+  const fraction = fractionValue(val);
+  if (fraction !== null) return fraction;
   return spacingLookup(val, negative);
 }
 var CONTAINER_WIDTHS = Object.freeze({
+  "3xs": "16rem",
+  "2xs": "18rem",
   xs: "20rem",
   sm: "24rem",
   md: "28rem",
@@ -1971,7 +2237,11 @@ var MAX_W_NAMED = Object.freeze({
   ...VIEWPORT_SIZES
 });
 var MIN_W_NAMED = Object.freeze({
+  // `auto` is a min-* value only: `max-width: auto` is not valid CSS, and
+  // Tailwind registers no `max-w-auto` either.
+  auto: "auto",
   "0": "0px",
+  ...CONTAINER_WIDTHS,
   full: "100%",
   min: "min-content",
   max: "max-content",
@@ -1980,6 +2250,7 @@ var MIN_W_NAMED = Object.freeze({
   ...VIEWPORT_SIZES
 });
 var MIN_H_NAMED = Object.freeze({
+  auto: "auto",
   "0": "0px",
   full: "100%",
   min: "min-content",
@@ -1999,6 +2270,15 @@ var MAX_H_NAMED = Object.freeze({
   screen: "100vh",
   ...VIEWPORT_SIZES
 });
+var SIZING_KEYWORDS = Object.freeze([
+  .../* @__PURE__ */ new Set([
+    ...Object.keys(NAMED_SIZES),
+    ...Object.keys(MIN_W_NAMED),
+    ...Object.keys(MAX_W_NAMED),
+    ...Object.keys(MIN_H_NAMED),
+    ...Object.keys(MAX_H_NAMED)
+  ])
+]);
 var CONSTRAINED_SIZE_TABLE = [
   ["min-w-", "min-width", MIN_W_NAMED],
   ["max-w-", "max-width", MAX_W_NAMED],
@@ -2011,7 +2291,8 @@ var CONSTRAINED_SIZE_TABLE = [
 ];
 function resolveConstrainedSize(val, named, property) {
   if (Object.hasOwn(named, val)) return single(property, named[val]);
-  if (Object.hasOwn(FRACTIONAL, val)) return single(property, FRACTIONAL[val]);
+  const fraction = fractionValue(val);
+  if (fraction !== null) return single(property, fraction);
   const arb = extractArbitrary(val);
   if (arb !== null) return single(property, arb);
   const spacingVal = spacingLookup(val, false);
@@ -2031,6 +2312,7 @@ function sizingGenerator(_utility, _value, full, negative, _theme, _warnings) {
     const val = full.slice(2);
     const resolved = resolveSizeValue(val, NAMED_SIZES, negative);
     if (resolved) return single("width", resolved);
+    if (Object.hasOwn(CONTAINER_WIDTHS, val)) return single("width", CONTAINER_WIDTHS[val]);
   }
   if (full.startsWith("h-")) {
     const val = full.slice(2);
@@ -2041,6 +2323,9 @@ function sizingGenerator(_utility, _value, full, negative, _theme, _warnings) {
     const val = full.slice(7);
     const resolved = resolveSizeValue(val, NAMED_SIZES, negative);
     if (resolved) return single("inline-size", resolved);
+    if (Object.hasOwn(CONTAINER_WIDTHS, val)) {
+      return single("inline-size", CONTAINER_WIDTHS[val]);
+    }
   }
   if (full.startsWith("block-")) {
     const val = full.slice(6);
@@ -2397,6 +2682,15 @@ function colorGenerator(utility, value, full, _negative, theme, _warnings, dataT
       if (resolved) return single(cssProperty, resolved);
     }
   }
+  if (full.startsWith("placeholder-")) {
+    const resolved = resolveColor(full.slice(12), theme, dataType);
+    if (resolved) {
+      return {
+        declarations: [{ property: "color", value: resolved }],
+        nestedSelector: "&::placeholder"
+      };
+    }
+  }
   if (full.startsWith("divide-") && !DIVIDE_NON_COLOR_RE.test(full)) {
     const colorName = full.slice(7);
     const resolved = resolveColor(colorName, theme, dataType);
@@ -2618,8 +2912,13 @@ function splitLineHeightModifier(s) {
   }
   return { base: s, modifier: null };
 }
+function numericLeading(value) {
+  return DECIMAL_RE.test(value) ? spacingLookup(value) : null;
+}
 function resolveLineHeightModifier(mod, theme) {
   if (Object.hasOwn(theme.leading, mod)) return theme.leading[mod];
+  const numeric = numericLeading(mod);
+  if (numeric !== null) return numeric;
   if (mod.startsWith("(") && mod.endsWith(")")) {
     const inner = mod.slice(1, -1);
     return /^--[a-zA-Z_][\w-]*$/.test(inner) ? `var(${inner})` : null;
@@ -2715,7 +3014,9 @@ function typographyGenerator(_utility, _value, full, negative, theme, warnings,
   if (full.startsWith("text-")) {
     const { base: sizeName, modifier } = splitLineHeightModifier(full.slice(5));
     const lh = modifier !== null ? resolveLineHeightModifier(modifier, theme) : null;
+    const modifierFailed = modifier !== null && lh === null;
     if (Object.hasOwn(theme.text, sizeName)) {
+      if (modifierFailed) return null;
       return multi(
         ["font-size", `var(--text-${sizeName})`],
         ["line-height", lh ?? `var(--text-${sizeName}-leading)`]
@@ -2724,6 +3025,7 @@ function typographyGenerator(_utility, _value, full, negative, theme, warnings,
     if (!isBracketedColor(sizeName)) {
       const arbText = extractArbitrary(sizeName);
       if (arbText) {
+        if (modifierFailed) return null;
         return lh !== null ? multi(["font-size", arbText], ["line-height", lh]) : single("font-size", arbText);
       }
     }
@@ -2772,6 +3074,8 @@ function typographyGenerator(_utility, _value, full, negative, theme, warnings,
     if (Object.hasOwn(theme.leading, name)) {
       return single("line-height", theme.leading[name]);
     }
+    const numeric = numericLeading(name);
+    if (numeric !== null) return single("line-height", numeric);
     const arbLeading = extractArbitrary(name);
     if (arbLeading) return single("line-height", arbLeading);
     if (name === "px") return single("line-height", "1px");
@@ -2910,11 +3214,6 @@ function checkAppliedFontWeights(classes, theme, warnings) {
 
 // src/utilities/layout.ts
 var ASPECT_RATIO_RE = /^(\d+)\/(\d+)$/;
-var CONTAINER_SCALE = Object.freeze({
-  "3xs": "16rem",
-  "2xs": "18rem",
-  ...CONTAINER_WIDTHS
-});
 function resolveGridLine(name, negative) {
   if (name === "auto") return "auto";
   if (INTEGER_RE.test(name)) return negative ? `calc(${name} * -1)` : name;
@@ -2922,14 +3221,6 @@ function resolveGridLine(name, negative) {
   if (arb !== null) return negative ? `calc(${arb} * -1)` : arb;
   return null;
 }
-function fractionToPercent(name) {
-  const slash = name.indexOf("/");
-  if (slash === -1) return null;
-  const num = Number(name.slice(0, slash));
-  const den = Number(name.slice(slash + 1));
-  if (!Number.isFinite(num) || !Number.isFinite(den) || den <= 0) return null;
-  return `${Math.round(num / den * 1e6) / 1e4}%`;
-}
 function resolveGridTemplate(name, property) {
   if (name === "none") return single(property, "none");
   if (name === "subgrid") return single(property, "subgrid");
@@ -3465,7 +3756,7 @@ function resolveColumns(full) {
   const name = full.slice(8);
   if (name === "auto") return single("columns", "auto");
   if (INTEGER_RE.test(name)) return single("columns", name);
-  if (Object.hasOwn(CONTAINER_SCALE, name)) return single("columns", CONTAINER_SCALE[name]);
+  if (Object.hasOwn(CONTAINER_WIDTHS, name)) return single("columns", CONTAINER_WIDTHS[name]);
   const arb = extractArbitrary(name);
   if (arb) return single("columns", arb);
   return null;
@@ -3490,19 +3781,18 @@ function resolveBasis(full) {
   const name = full.slice(6);
   const arb = extractArbitrary(name);
   if (arb !== null) return single("flex-basis", arb);
-  const pct = fractionToPercent(name);
+  if (Object.hasOwn(CONTAINER_WIDTHS, name)) return single("flex-basis", CONTAINER_WIDTHS[name]);
+  const pct = fractionValue(name);
   if (pct !== null) return single("flex-basis", pct);
-  if (DECIMAL_RE.test(name)) {
-    const sp = spacingLookup(name, false);
-    if (sp) return single("flex-basis", sp);
-  }
+  const sp = spacingLookup(name, false);
+  if (sp) return single("flex-basis", sp);
   return null;
 }
 function resolveFlex(full) {
   const name = full.slice(5);
   const arb = extractArbitrary(name);
   if (arb !== null) return single("flex", arb);
-  const pct = fractionToPercent(name);
+  const pct = fractionValue(name);
   if (pct !== null) return single("flex", pct);
   if (DECIMAL_RE.test(name)) return single("flex", normalizeDecimalToken(name));
   return null;
@@ -3787,9 +4077,17 @@ function borderGenerator(_utility, _value, full, negative, theme, _warnings, dat
       return multi(["corner-shape", arb], ["--ri-rounded-scale", "1"]);
     }
   }
+  if (full === "rounded") {
+    const r = resolveRadius("DEFAULT", theme);
+    if (r) return single("border-radius", r);
+  }
   if (full.startsWith("rounded-")) {
     const rest = full.slice(8);
     for (const [suffix, prop] of ROUNDED_CORNER_ENTRIES) {
+      if (rest === suffix) {
+        const r2 = resolveRadius("DEFAULT", theme);
+        if (r2) return single(prop, r2);
+      }
       if (rest.startsWith(suffix) && rest.charCodeAt(suffix.length) === 45) {
         const size = rest.slice(suffix.length + 1);
         const r2 = resolveRadius(size, theme);
@@ -3797,6 +4095,10 @@ function borderGenerator(_utility, _value, full, negative, theme, _warnings, dat
       }
     }
     for (const [suffix, props] of ROUNDED_SIDE_ENTRIES) {
+      if (rest === suffix) {
+        const r2 = resolveRadius("DEFAULT", theme);
+        if (r2) return multi(...props.map((p) => [p, r2]));
+      }
       if (rest.startsWith(suffix) && rest.charCodeAt(suffix.length) === 45) {
         const size = rest.slice(suffix.length + 1);
         const r2 = resolveRadius(size, theme);
@@ -3864,6 +4166,143 @@ function borderGenerator(_utility, _value, full, negative, theme, _warnings, dat
   return null;
 }
 
+// src/css/shadow-color.ts
+var SHADOW_KEYWORDS = /* @__PURE__ */ new Set([
+  "inset",
+  "inherit",
+  "initial",
+  "revert",
+  "revert-layer",
+  "unset"
+]);
+var MATH_FUNCTIONS2 = /* @__PURE__ */ new Set(["calc", "clamp", "min", "max"]);
+var COLOR_FUNCTIONS = /* @__PURE__ */ new Set([
+  "color",
+  "color-mix",
+  "contrast-color",
+  "device-cmyk",
+  "hsl",
+  "hsla",
+  "hwb",
+  "lab",
+  "lch",
+  "light-dark",
+  "oklab",
+  "oklch",
+  "rgb",
+  "rgba"
+]);
+var LENGTH_START_RE = /^-?(?:\d+|\.\d+)/;
+function splitShadowLayers(value) {
+  const layers = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth = Math.max(0, depth - 1);
+    else if (ch === "," && depth === 0) {
+      layers.push(value.slice(start, i));
+      start = i + 1;
+    }
+  }
+  layers.push(value.slice(start));
+  return layers;
+}
+function tokenizeLayer(layer) {
+  const tokens = [];
+  let i = 0;
+  while (i < layer.length) {
+    if (/\s/.test(layer[i])) {
+      i++;
+      continue;
+    }
+    const start = i;
+    let depth = 0;
+    let isFunction = false;
+    while (i < layer.length) {
+      const ch = layer[i];
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "(") {
+        if (depth === 0) isFunction = true;
+        depth++;
+      } else if (ch === ")") {
+        depth = Math.max(0, depth - 1);
+      } else if (depth === 0 && /\s/.test(ch)) {
+        break;
+      }
+      i++;
+    }
+    tokens.push({ start, end: i, text: layer.slice(start, i), isFunction });
+  }
+  return tokens;
+}
+function functionName(text) {
+  const open = text.indexOf("(");
+  return open === -1 ? "" : text.slice(0, open).toLowerCase();
+}
+function slotLayer(layer, colorVar) {
+  const trimmed = layer.trim();
+  if (trimmed === "") return layer;
+  const bang = /!\s*important\s*$/i.exec(trimmed);
+  const core = bang === null ? trimmed : trimmed.slice(0, bang.index).trimEnd();
+  const suffix = bang === null ? "" : ` ${trimmed.slice(bang.index)}`;
+  if (core === "") return layer;
+  const lead = layer.slice(0, layer.indexOf(trimmed));
+  const trail = layer.slice(lead.length + trimmed.length);
+  const tokens = tokenizeLayer(core);
+  let lengths = 0;
+  let values = 0;
+  let last = null;
+  let hit = null;
+  for (const token of tokens) {
+    if (token.isFunction) {
+      const name = functionName(token.text);
+      if (COLOR_FUNCTIONS.has(name)) {
+        hit = token;
+        break;
+      }
+      if (MATH_FUNCTIONS2.has(name)) {
+        lengths++;
+        continue;
+      }
+      last = token;
+      values++;
+      continue;
+    }
+    if (SHADOW_KEYWORDS.has(token.text.toLowerCase())) continue;
+    if (token.text.startsWith("#")) {
+      hit = token;
+      break;
+    }
+    if (LENGTH_START_RE.test(token.text)) {
+      lengths++;
+      continue;
+    }
+    last = token;
+    values++;
+  }
+  const wrap = (token) => {
+    if (token.text.startsWith(`var(${colorVar}`)) return layer;
+    return lead + core.slice(0, token.start) + `var(${colorVar}, ${token.text})` + core.slice(token.end) + suffix + trail;
+  };
+  if (hit !== null) return wrap(hit);
+  if (lengths < 2) return layer;
+  if (values === 0) return `${lead + core} var(${colorVar}, currentColor)${suffix}${trail}`;
+  if (values === 1 && last !== null) return wrap(last);
+  return layer;
+}
+function withShadowColorSlotLayers(value, colorVar) {
+  return splitShadowLayers(value).map((layer) => slotLayer(layer, colorVar).trim());
+}
+
 // src/utilities/effects/shadows.ts
 var SHADOW_COMPOSITION = "var(--ri-inset-shadow, 0 0 #0000), var(--ri-inset-ring-shadow, 0 0 #0000), var(--ri-ring-offset-shadow, 0 0 #0000), var(--ri-ring-shadow, 0 0 #0000), var(--ri-shadow, 0 0 #0000)";
 function composedShadow(slot, value) {
@@ -3887,58 +4326,103 @@ function resolveColorOrArbitrary(name, colorVar, theme, dataType, onArbitrary) {
   }
   return null;
 }
-function resolveShadowFamily(name, noneValue, colorVar, theme, dataType, wrap) {
-  if (name === "none") return wrap(noneValue);
-  return resolveColorOrArbitrary(name, colorVar, theme, dataType, wrap);
-}
-function resolveShadow(full, theme, dataType) {
-  const name = full === "shadow" ? Object.hasOwn(theme.shadows, "DEFAULT") ? "DEFAULT" : Object.hasOwn(theme.shadows, "md") ? "md" : "" : full.slice(7);
-  if (Object.hasOwn(theme.shadows, name))
-    return composedShadow("--ri-shadow", `var(--shadow-${name})`);
-  if (name === "none") return composedShadow("--ri-shadow", "0 0 #0000");
+function resolveShadowFamily(name, theme, dataType, family) {
+  if (name === "none") return family.wrap([family.none]);
+  if (family.initial && name === "initial") return single(family.colorVar, "initial");
   return resolveColorOrArbitrary(
     name,
-    "--ri-shadow-color",
+    family.colorVar,
     theme,
     dataType,
-    (arb) => composedShadow("--ri-shadow", arb)
+    (arb) => family.wrap(withShadowColorSlotLayers(arb, family.colorVar))
   );
 }
-function resolveInsetShadow(full, theme, dataType) {
-  return resolveShadowFamily(
-    full.slice(13),
-    // "inset-shadow-".length
-    "inset 0 0 #0000",
-    "--ri-inset-shadow-color",
-    theme,
-    dataType,
-    (value) => composedShadow("--ri-inset-shadow", value)
-  );
+var BOX_SHADOW = {
+  none: "0 0 #0000",
+  colorVar: "--ri-shadow-color",
+  initial: true,
+  wrap: (layers) => composedShadow("--ri-shadow", layers.join(", "))
+};
+var INSET_SHADOW = {
+  none: "inset 0 0 #0000",
+  colorVar: "--ri-inset-shadow-color",
+  initial: true,
+  wrap: (layers) => composedShadow("--ri-inset-shadow", layers.join(", "))
+};
+var TEXT_SHADOW = {
+  none: "none",
+  colorVar: "--ri-text-shadow-color",
+  initial: true,
+  wrap: (layers) => single("text-shadow", layers.join(", "))
+};
+function resolveShadow(full, theme, dataType) {
+  const name = full === "shadow" ? Object.hasOwn(theme.shadows, "DEFAULT") ? "DEFAULT" : Object.hasOwn(theme.shadows, "md") ? "md" : "" : full.slice(7);
+  if (Object.hasOwn(theme.shadows, name)) {
+    return BOX_SHADOW.wrap(withShadowColorSlotLayers(theme.shadows[name], BOX_SHADOW.colorVar));
+  }
+  return resolveShadowFamily(name, theme, dataType, BOX_SHADOW);
 }
-function resolveRingFamily(name, slot, colorVar, insetPrefix, theme, dataType) {
-  const ring = (width) => composedShadow(slot, `${insetPrefix}0 0 0 ${width} var(${colorVar}, currentColor)`);
+function resolveInsetShadow(full, theme, dataType) {
+  return resolveShadowFamily(full.slice(13), theme, dataType, INSET_SHADOW);
+}
+var RING_INSET_FLAG = "var(--ri-ring-inset, ) ";
+var RING_OFFSET_WIDTH = "var(--ri-ring-offset-width, 0px)";
+var RING = {
+  slot: "--ri-ring-shadow",
+  colorVar: "--ri-ring-color",
+  insetPrefix: RING_INSET_FLAG,
+  offsetAware: true
+};
+var INSET_RING = {
+  slot: "--ri-inset-ring-shadow",
+  colorVar: "--ri-inset-ring-color",
+  insetPrefix: "inset ",
+  offsetAware: false
+};
+function resolveRingFamily(name, theme, dataType, family) {
+  const ring = (width) => {
+    const w = family.offsetAware ? `calc(${width} + ${RING_OFFSET_WIDTH})` : width;
+    return composedShadow(
+      family.slot,
+      `${family.insetPrefix}0 0 0 ${w} var(${family.colorVar}, currentColor)`
+    );
+  };
   if (name === "") return ring("1px");
   if (INTEGER_RE.test(name)) return ring(`${name}px`);
-  return resolveColorOrArbitrary(name, colorVar, theme, dataType, (arb) => ring(arb));
+  return resolveColorOrArbitrary(name, family.colorVar, theme, dataType, (arb) => ring(arb));
 }
-function resolveRing(full, theme, dataType) {
-  return resolveRingFamily(
-    full === "ring" ? "" : full.slice(5),
-    "--ri-ring-shadow",
-    "--ri-ring-color",
-    "",
+function resolveRingOffset(full, theme, dataType) {
+  const name = full.slice(12);
+  const offset = (width) => multi(
+    ["--ri-ring-offset-width", width],
+    [
+      "--ri-ring-offset-shadow",
+      `${RING_INSET_FLAG}0 0 0 ${RING_OFFSET_WIDTH} var(--ri-ring-offset-color, #fff)`
+    ]
+  );
+  if (INTEGER_RE.test(name)) return offset(`${name}px`);
+  return resolveColorOrArbitrary(
+    name,
+    "--ri-ring-offset-color",
     theme,
-    dataType
+    dataType,
+    (arb) => offset(arb)
   );
 }
+function resolveRing(full, theme, dataType) {
+  const offset = full.startsWith("ring-offset-") ? resolveRingOffset(full, theme, dataType) : null;
+  if (offset) return offset;
+  const ring = resolveRingFamily(full === "ring" ? "" : full.slice(5), theme, dataType, RING);
+  if (ring) return ring;
+  if (full === "ring-inset") return single("--ri-ring-inset", "inset");
+  return null;
+}
 function resolveInsetRing(full, theme, dataType) {
   return resolveRingFamily(
     full === "inset-ring" ? "" : full.slice(11),
-    "--ri-inset-ring-shadow",
-    "--ri-inset-ring-color",
-    "inset ",
     theme,
-    dataType
+    dataType,
+    INSET_RING
   );
 }
 function resolveInset(full, theme, dataType) {
@@ -3948,15 +4432,7 @@ function resolveInset(full, theme, dataType) {
   return null;
 }
 function resolveTextShadow(full, theme, dataType) {
-  return resolveShadowFamily(
-    full.slice(12),
-    // "text-shadow-".length
-    "none",
-    "--ri-text-shadow-color",
-    theme,
-    dataType,
-    (value) => single("text-shadow", value)
-  );
+  return resolveShadowFamily(full.slice(12), theme, dataType, TEXT_SHADOW);
 }
 
 // src/utilities/effects/transitions.ts
@@ -4051,14 +4527,32 @@ function resolveTransition(full) {
 }
 
 // src/utilities/effects/filters.ts
-var FILTER_COMPOSED = "var(--ri-blur, ) var(--ri-brightness, ) var(--ri-contrast, ) var(--ri-grayscale, ) var(--ri-hue-rotate, ) var(--ri-invert, ) var(--ri-saturate, ) var(--ri-sepia, ) var(--ri-drop-shadow, )";
-var BACKDROP_FILTER_COMPOSED = "var(--ri-backdrop-blur, ) var(--ri-backdrop-brightness, ) var(--ri-backdrop-contrast, ) var(--ri-backdrop-grayscale, ) var(--ri-backdrop-hue-rotate, ) var(--ri-backdrop-invert, ) var(--ri-backdrop-saturate, ) var(--ri-backdrop-sepia, ) var(--ri-backdrop-opacity, )";
+var DROP_SHADOW = {
+  none: "0 0 #0000",
+  colorVar: "--ri-drop-shadow-color",
+  initial: false,
+  // One `drop-shadow()` per layer, space-joined: the function takes a single
+  // shadow, so a two-layer value written as `drop-shadow(a, b)` is invalid and
+  // drops silently.
+  wrap: (layers) => multi(
+    ["--ri-drop-shadow", layers.map((l) => `drop-shadow(${l})`).join(" ")],
+    ["filter", FILTER_COMPOSED]
+  )
+};
 var FILTER_STATICS = {
   // Filter — grayscale/invert/sepia (bare + numeric) are handled dynamically via
-  // FILTER_TABLE (bare100); only the literal `filter-none` reset is static here.
+  // FILTER_TABLE (bare100). Bare `filter` enables the chain and contributes
+  // nothing of its own, which is what makes a v3-era `filter blur-sm` string
+  // work; `filter-none` is the reset.
+  filter: single("filter", FILTER_COMPOSED),
   "filter-none": single("filter", "none"),
-  // Backdrop filter
-  "backdrop-blur-none": single("backdrop-filter", "none")
+  // Backdrop filter. `backdrop-blur-none` is NOT here: it clears the blur slot
+  // and re-emits the chain, exactly as `blur-none` does, so it composes with
+  // the other backdrop functions instead of erasing them. It used to be
+  // `backdrop-filter: none`, which is the v3 reading — v4.3.3 emits
+  // `--tw-backdrop-blur: ;` followed by the chain, and `backdrop-filter-none`
+  // is the spelling that really does reset everything.
+  "backdrop-filter": single("backdrop-filter", BACKDROP_FILTER_COMPOSED)
 };
 deepFreezeUtilityMap(FILTER_STATICS);
 var FILTER_TABLE = [
@@ -4115,15 +4609,7 @@ function resolveFilter(full, negative, theme, dataType) {
     if (r !== void 0) return r;
   }
   if (full.startsWith("drop-shadow-")) {
-    return resolveShadowFamily(
-      full.slice(12),
-      // "drop-shadow-".length
-      "0 0 #0000",
-      "--ri-drop-shadow-color",
-      theme,
-      dataType,
-      (value) => multi(["--ri-drop-shadow", `drop-shadow(${value})`], ["filter", FILTER_COMPOSED])
-    );
+    return resolveShadowFamily(full.slice(12), theme, dataType, DROP_SHADOW);
   }
   return null;
 }
@@ -4147,6 +4633,12 @@ function resolveBackdropFilter(full, theme, negative) {
   if (full.startsWith("backdrop-blur-")) {
     const name = full.slice(14);
     if (name === "") return null;
+    if (name === "none" && !Object.hasOwn(theme.blur, name)) {
+      return multi(
+        ["--ri-backdrop-blur", "blur(0)"],
+        ["backdrop-filter", BACKDROP_FILTER_COMPOSED]
+      );
+    }
     const blur = resolveBlurValue(
       name,
       theme,
@@ -4181,8 +4673,12 @@ function resolveBackdropFilter(full, theme, negative) {
 
 // src/utilities/effects/transforms.ts
 var TRANSFORM_COMPOSED = "var(--ri-rotate-x, rotateX(0)) var(--ri-rotate-y, rotateY(0)) var(--ri-rotate-z, rotateZ(0)) var(--ri-skew-x, skewX(0)) var(--ri-skew-y, skewY(0))";
+var TRANSLATE_XYZ = "var(--ri-translate-x, 0) var(--ri-translate-y, 0) var(--ri-translate-z, 0)";
 var TRANSFORM_STATICS = {
-  // Transform
+  // Transform. Bare `transform` and `transform-cpu` are the same declaration —
+  // upstream emits them byte-identically; `-cpu` is the v3-era spelling kept
+  // as the explicit opposite of `-gpu`. Do not "dedupe" the pair away.
+  transform: single("transform", TRANSFORM_COMPOSED),
   "transform-none": single("transform", "none"),
   "transform-gpu": single("transform", `translateZ(0) ${TRANSFORM_COMPOSED}`),
   "transform-cpu": single("transform", TRANSFORM_COMPOSED),
@@ -4197,6 +4693,7 @@ var TRANSFORM_STATICS = {
   "transform-view": single("transform-box", "view-box"),
   // Translate reset
   "translate-none": single("translate", "none"),
+  "translate-3d": single("translate", TRANSLATE_XYZ),
   // Rotate reset
   "rotate-none": single("rotate", "none"),
   // Scale reset
@@ -4231,14 +4728,8 @@ function resolveTranslate(full, negative) {
     ) : null;
   }
   if (full.startsWith("translate-z-")) {
-    const val = resolveTransformValue(full.slice(12), negative);
-    return val ? multi(
-      ["--ri-translate-z", val],
-      [
-        "translate",
-        "var(--ri-translate-x, 0) var(--ri-translate-y, 0) var(--ri-translate-z, 0)"
-      ]
-    ) : null;
+    const val = resolveTransformValue(full.slice(12), negative, false);
+    return val ? multi(["--ri-translate-z", val], ["translate", TRANSLATE_XYZ]) : null;
   }
   if (full.startsWith("translate-")) {
     const val = resolveTransformValue(full.slice(10), negative);
@@ -4378,9 +4869,15 @@ function resolveSkew(full, negative) {
     ["transform", TRANSFORM_COMPOSED]
   );
 }
-function resolveTransformValue(name, negative) {
-  if (name === "full") return negative ? "-100%" : "100%";
-  if (name === "1/2") return negative ? "-50%" : "50%";
+function resolveTransformValue(name, negative, percentOk = true) {
+  if (percentOk) {
+    if (name === "full") return negative ? "-100%" : "100%";
+    const fraction = fractionValue(name);
+    if (fraction !== null) {
+      if (!negative) return fraction;
+      return fraction.startsWith("calc(") ? `calc(${fraction} * -1)` : `-${fraction}`;
+    }
+  }
   const arb = extractArbitrary(name);
   if (arb !== null) return negative ? `calc(${arb} * -1)` : arb;
   return spacingLookup(name, negative);
@@ -4972,6 +5469,8 @@ function svgGenerator(_utility, _value, full, _negative, _theme) {
 }
 
 // src/utilities/roots.ts
+var CONTAINER_KEYS = Object.keys(CONTAINER_WIDTHS);
+var FRACTION_KEYS = Object.keys(FRACTIONAL);
 var SPACING_SAMPLES = Object.freeze([
   "0",
   "1",
@@ -5001,8 +5500,12 @@ var COLOR_BORDER = [colorGenerator, borderGenerator];
 var EFFECTS = [effectsGenerator];
 var ANIMATION_EFFECTS = [animationGenerator, effectsGenerator];
 var STATICS_ONLY = { kinds: [] };
-var SHADOW_SPEC = { kinds: ["shadow", "color", "special-color"] };
+var SHADOW_SPEC = {
+  kinds: ["shadow", "color", "special-color"],
+  keywords: ["none", "initial"]
+};
 var RING_SPEC = { kinds: ["int", "color", "special-color"] };
+var OUTER_RING_SPEC = { ...RING_SPEC, keywords: ["inset"] };
 var ROTATE_SKEW_SPEC = {
   kinds: ["keywords"],
   keywords: [
@@ -5104,21 +5607,36 @@ var ROOT_GROUPS = [
     resolvers: SPACING,
     spec: { kinds: ["fluid-range"] }
   },
-  // Sizing
+  // Sizing. Every root here is offered the whole union of named sizing values
+  // and its own table decides — the enumerator drops a candidate that does not
+  // resolve, so a shared list cannot over-report, while a per-root list can and
+  // did under-report (the logical spellings had none of their own).
+  {
+    roots: ["h", "size", "min", "max"],
+    resolvers: SIZING,
+    spec: { kinds: ["spacing", "fraction"], keywords: SIZING_KEYWORDS }
+  },
   {
-    roots: ["w", "h", "size", "min", "max", "min-w"],
+    // The inline axis reads the container ladder; the block axis does not,
+    // which is why these two are not in the row above.
+    roots: ["w", "min-w", "inline", "min-inline", "max-inline"],
     resolvers: SIZING,
-    spec: { kinds: ["spacing", "fraction"] }
+    spec: { kinds: ["spacing", "fraction"], keywords: [...CONTAINER_KEYS, ...SIZING_KEYWORDS] }
   },
   {
     roots: ["max-w"],
     resolvers: SIZING,
-    spec: { kinds: ["spacing", "fraction", "breakpoint"] }
+    spec: { kinds: ["spacing", "fraction"], keywords: [...CONTAINER_KEYS, ...SIZING_KEYWORDS] }
   },
   {
-    roots: ["min-h", "max-h"],
+    // `min-block` / `max-block` are roots in their own right, the way
+    // `min-inline` / `max-inline` are. Without them these fell through to the
+    // bare `min` / `max` roots, where the value would have had to be spelled
+    // `block-full` — so the whole logical block axis was unenumerable while
+    // resolving perfectly well.
+    roots: ["min-h", "max-h", "min-block", "max-block"],
     resolvers: SIZING,
-    spec: { kinds: ["spacing", "fraction"] }
+    spec: { kinds: ["spacing", "fraction"], keywords: SIZING_KEYWORDS }
   },
   // Typography
   {
@@ -5234,7 +5752,7 @@ var ROOT_GROUPS = [
     spec: { kinds: ["color", "special-color", "int"] }
   },
   {
-    roots: ["accent", "caret", "fill"],
+    roots: ["accent", "caret", "fill", "placeholder"],
     resolvers: COLOR_BORDER_EFFECTS_SVG,
     spec: { kinds: ["color", "special-color"] }
   },
@@ -5403,7 +5921,7 @@ var ROOT_GROUPS = [
   {
     roots: ["columns"],
     resolvers: LAYOUT,
-    spec: { kinds: ["breakpoint", "int"] }
+    spec: { kinds: ["int"], keywords: CONTAINER_KEYS }
   },
   {
     roots: ["sr"],
@@ -5423,7 +5941,7 @@ var ROOT_GROUPS = [
   {
     roots: ["basis"],
     resolvers: LAYOUT,
-    spec: { kinds: ["spacing", "fraction", "breakpoint"] }
+    spec: { kinds: ["spacing", "fraction"], keywords: CONTAINER_KEYS }
   },
   // caret/accent color values are registered on the color-bearing row above.
   {
@@ -5455,7 +5973,7 @@ var ROOT_GROUPS = [
   {
     roots: ["inline", "block"],
     resolvers: SIZING,
-    spec: { kinds: ["spacing", "fraction"] }
+    spec: { kinds: ["spacing", "fraction"], keywords: SIZING_KEYWORDS }
   },
   // Borders
   {
@@ -5501,6 +6019,14 @@ var ROOT_GROUPS = [
   {
     roots: ["ring"],
     resolvers: EFFECTS,
+    spec: OUTER_RING_SPEC
+  },
+  // `ring-offset-*` shares the ring's value space — an integer width or a
+  // colour — but is its own root so the enumerator offers the whole family
+  // rather than leaving it to be spelled through `ring`.
+  {
+    roots: ["ring-offset"],
+    resolvers: EFFECTS,
     spec: RING_SPEC
   },
   {
@@ -5580,10 +6106,18 @@ var ROOT_GROUPS = [
   // Statics-only registration for the remaining filter roots — their dynamic
   // value spaces (percentages, angles, drop-shadow tokens) are not enumerated.
   {
-    roots: ["brightness", "contrast", "saturate", "hue", "drop"],
+    roots: ["brightness", "contrast", "saturate", "hue"],
     resolvers: EFFECTS,
     spec: STATICS_ONLY
   },
+  {
+    // `drop-shadow-*` dispatches through the bare `drop` root, so its value
+    // carries the `shadow-` segment. Only the two namespace-free spellings
+    // are listed; the named scale comes from the preset's @utility blocks.
+    roots: ["drop"],
+    resolvers: EFFECTS,
+    spec: { kinds: ["keywords"], keywords: ["shadow-none", "shadow-initial"] }
+  },
   {
     roots: ["mask"],
     resolvers: EFFECTS,
@@ -5601,6 +6135,11 @@ var ROOT_GROUPS = [
       kinds: ["keywords"],
       keywords: [
         ...SPACING_SAMPLES.flatMap((s) => [`x-${s}`, `y-${s}`, `z-${s}`]),
+        // Every fraction on both axes and the shorthand — the resolver
+        // reads the whole shared FRACTIONAL table, so a spec listing only
+        // `1/2` would under-report the family by 75 names.
+        ...FRACTION_KEYS.flatMap((f) => [`x-${f}`, `y-${f}`, f]),
+        "3d",
         "x-full",
         "y-full",
         "x-1/2",
@@ -6136,6 +6675,12 @@ var PROPERTY_GROUPS = Object.assign(/* @__PURE__ */ Object.create(null), {
   "--ri-inset-shadow-color": 141,
   "--ri-ring-color": 141,
   "--ri-inset-ring-color": 141,
+  "--ri-ring-offset-color": 141,
+  // Width and flag are read by the ring/offset shadow layers rather than by a
+  // property of their own, so they belong to the same group for the same
+  // reason the slot vars do.
+  "--ri-ring-offset-width": 141,
+  "--ri-ring-inset": 141,
   "text-shadow": 141,
   "--ri-text-shadow-color": 141,
   outline: 142,
@@ -6216,16 +6761,24 @@ var PROPERTY_GROUPS = Object.assign(/* @__PURE__ */ Object.create(null), {
   "--ri-rotate-z": 160,
   "--ri-skew-x": 160,
   "--ri-skew-y": 160,
-  translate: 161,
   "--ri-translate-x": 161,
   "--ri-translate-y": 161,
   "--ri-translate-z": 161,
-  rotate: 162,
-  scale: 163,
-  "--ri-scale-x": 163,
-  "--ri-scale-y": 163,
-  "--ri-scale-z": 163,
-  zoom: 164,
+  // The whole-property `translate` sorts AFTER the axis variables, not with
+  // them. `translate-none` and `translate-3d` are the only utilities whose
+  // first declaration is the shorthand, and both are meant to win over an axis
+  // utility beside them — a reset that loses to `translate-x-4` resets nothing,
+  // and `translate-3d` exists precisely to re-emit the shorthand with the Z
+  // axis in it. Sharing 161 left the codepoint tie-break to decide, and it put
+  // `.translate-3d` and `.translate-none` first, so both were inert.
+  // Tailwind orders them last for the same reason.
+  translate: 162,
+  rotate: 163,
+  scale: 164,
+  "--ri-scale-x": 164,
+  "--ri-scale-y": 164,
+  "--ri-scale-z": 164,
+  zoom: 165,
   // Transition / Animation
   transition: 170,
   "transition-property": 171,
@@ -6868,6 +7421,11 @@ function compileUtility(parsed, theme, result, customVariantMap, warnSeen, break
   }
   const utilResult = resolveUtilityDeclarations(parsed, theme, result.warnings);
   if (!utilResult) {
+    if (detail && parsed.raw === parsed.utility && isMarkerUtility(parsed.utility)) {
+      detail.reason = "marker";
+      detail.declarations = [];
+      return null;
+    }
     if (detail) detail.reason = "unknown-utility";
     return null;
   }
@@ -6913,43 +7471,51 @@ function compileUtility(parsed, theme, result, customVariantMap, warnSeen, break
     if (!wrappers) wrappers = [];
     wrappers.push(wrapper);
   }
-  let atRuleOpen = "";
-  let atRuleClose = "";
-  let startingStyleWrap = false;
-  if (wrappers) {
-    const applied = applyVariantWrappers(selector, wrappers);
-    selector = applied.selector;
-    for (const atRule of applied.atRules) {
+  const renderBranch = (branch) => {
+    let atRuleOpen = "";
+    let atRuleClose = "";
+    for (const atRule of branch.atRules) {
       atRuleOpen += `${atRule} {
 `;
       atRuleClose = `}
 ${atRuleClose}`;
     }
-    startingStyleWrap = applied.startingStyle;
-  }
-  let css;
-  if (startingStyleWrap) {
-    const indentedDecls = declCSS.replace(/\n/g, "\n  ");
-    css = `${selector} {
+    let out;
+    if (branch.startingStyle) {
+      const indentedDecls = declCSS.replace(/\n/g, "\n  ");
+      out = `${branch.selector} {
   @starting-style {
   ${indentedDecls}
   }
 }`;
-  } else {
-    css = `${selector} {
+    } else {
+      out = `${branch.selector} {
 ${declCSS}
 }`;
-  }
-  if (atRuleOpen) {
-    css = `${atRuleOpen}${css}
-${atRuleClose}`;
+    }
+    return atRuleOpen ? `${atRuleOpen}${out}
+${atRuleClose}` : out;
+  };
+  let css;
+  if (wrappers) {
+    const branches = applyVariantWrappers(selector, wrappers);
+    selector = branches[0].selector;
+    css = branches.map(renderBranch).join("\n\n");
+  } else {
+    css = renderBranch({ selector, atRules: [], startingStyle: false });
   }
   const cssProperty = utilResult.declarations[0]?.property || "";
   const sortKey = computeSortKey(cssProperty, parsed.variants, breakpointWeights);
   return { selector, sortKey, css };
 }
+function indentBlock(body) {
+  return body.split("\n").map((line) => line.trim() === "" ? "" : `  ${line}`).join("\n");
+}
 function scanStringForTokenUsage(str, result) {
   if (str.includes("var(--color-")) {
+    for (const m of str.matchAll(COLOR_VAR_REF_RE)) {
+      result.usedColorNames.add(m[1]);
+    }
     for (const m of str.matchAll(COLOR_STOP_REF_RE)) {
       const hue = m[1];
       const suffix = m[2] ? Number(m[2]) : void 0;
@@ -7021,6 +7587,7 @@ function createEmptyCompilationResult() {
     keyframes: [],
     properties: [],
     usedColorStops: /* @__PURE__ */ new Map(),
+    usedColorNames: /* @__PURE__ */ new Set(),
     usedTextSizes: /* @__PURE__ */ new Set(),
     usedFonts: /* @__PURE__ */ new Set(),
     usedShadows: /* @__PURE__ */ new Set(),
@@ -7063,6 +7630,7 @@ function compileClassEntry(raw, theme, customVariantMap, breakpointWeights, vari
     warnings: scratch.warnings,
     arbitraryWarning,
     usedColorStops: scratch.usedColorStops,
+    usedColorNames: scratch.usedColorNames,
     usedTextSizes: scratch.usedTextSizes,
     usedFonts: scratch.usedFonts,
     usedShadows: scratch.usedShadows,
@@ -7148,6 +7716,7 @@ function compileInternal(classNames, theme, variantMapCache, authored) {
       }
       for (const stop of stops) set.add(stop);
     }
+    for (const v of entry.usedColorNames) result.usedColorNames.add(v);
     for (const v of entry.usedTextSizes) result.usedTextSizes.add(v);
     for (const v of entry.usedFonts) result.usedFonts.add(v);
     for (const v of entry.usedShadows) result.usedShadows.add(v);
@@ -7181,7 +7750,7 @@ function compileInternal(classNames, theme, variantMapCache, authored) {
   for (const [name, def] of Object.entries(theme.animations)) {
     if (def.keyframes && animationBases.has(`animate-${name}`)) {
       result.keyframes.push(`@keyframes ${name} {
-  ${def.keyframes}
+${indentBlock(def.keyframes)}
 }`);
     }
   }
@@ -7360,19 +7929,26 @@ function readURLImportTarget(src, start) {
   if (src[i] === ")") i++;
   return { target: target || null, nextIndex: i };
 }
-function scanImportTarget(src, paramsStart) {
+function readImportTarget(src, paramsStart) {
   let i = paramsStart;
   while (i < src.length && WS_RE2.test(src[i])) i++;
-  if (i >= src.length) return null;
+  if (i >= src.length) return { target: null, nextIndex: i };
   if (src[i] === '"' || src[i] === "'") {
-    return readQuotedImportTarget(src, i).target;
+    return readQuotedImportTarget(src, i);
   }
-  return readURLImportTarget(src, i).target;
+  return readURLImportTarget(src, i);
 }
-var RI_IMPORT_SPECIFIERS = Object.freeze([
+function scanImportTarget(src, paramsStart) {
+  return readImportTarget(src, paramsStart).target;
+}
+var RI_MARKER_IMPORT_SPECIFIERS = Object.freeze([
   "rainbowindex",
   "rainbowindex/index.css"
 ]);
+var RI_IMPORT_SPECIFIERS = Object.freeze([
+  ...RI_MARKER_IMPORT_SPECIFIERS,
+  "rainbowindex/tailwind.css"
+]);
 var RI_IMPORT_SPECIFIER_ALTERNATION = RI_IMPORT_SPECIFIERS.map(
   (s) => s.replace(/[/\\^$.*+?()[\]{}|]/g, "\\$&")
 ).join("|");
@@ -7479,9 +8055,15 @@ function splitColorAlpha(side) {
   }
   return { base: side, alpha: null };
 }
-function expandColorSide(side) {
+var COLOR_KEYWORDS = /* @__PURE__ */ new Set(["transparent", "currentColor", "inherit"]);
+function expandBareColorRef(v) {
+  if (COLOR_KEYWORDS.has(v)) return v;
+  return /^[\w-]+$/.test(v) ? `var(--color-${v})` : v;
+}
+function expandColorSide(side, bareNames = false) {
   const { base, alpha } = splitColorAlpha(side);
-  const expanded = expandColorStopRef(base);
+  const stop = expandColorStopRef(base);
+  const expanded = stop !== base || !(bareNames || alpha !== null) ? stop : expandBareColorRef(base);
   if (alpha === null) return expanded;
   const isPercent = alpha.endsWith("%");
   const num = Number.parseFloat(isPercent ? alpha.slice(0, -1) : alpha);
@@ -7496,15 +8078,26 @@ function parseColorBody(body, warnings) {
   for (const entry of scanEntries(cleanedBody, { newlineTerminates: true })) {
     if (entry.removal) {
       removals.push(entry.key);
+      if (entry.legacyRemoval) {
+        warnings?.push(legacySyntaxWarning(`!${entry.key};`, `${entry.key}: initial;`, "color"));
+      }
       continue;
     }
+    let { key, value } = entry;
+    let darkBlockOverride = null;
     if (entry.fragment) {
-      warnings?.push(
-        `[RI-1035] Invalid @color key "${entry.value}" \u2014 color names may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
-      );
-      continue;
+      if (entry.block === void 0) {
+        warnings?.push(
+          `[RI-1035] Invalid @color key "${entry.value}" \u2014 color names may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
+        );
+        continue;
+      }
+      const nested = readNestedColorEntry(entry.value, entry.block, warnings);
+      if (nested === null) continue;
+      key = entry.value;
+      value = nested.value;
+      darkBlockOverride = nested.options;
     }
-    const { key, value } = entry;
     if (!key || !value) continue;
     if (colorCount >= MAX_COLOR_ENTRIES) {
       warnings?.push(
@@ -7518,7 +8111,16 @@ function parseColorBody(body, warnings) {
       );
       continue;
     }
-    const darkBlock = entry.block ?? null;
+    const darkBlock = darkBlockOverride ?? entry.block ?? null;
+    if (darkBlockOverride === null && entry.block !== void 0) {
+      warnings?.push(
+        legacySyntaxWarning(
+          `${key}: <value> { \u2026 }`,
+          `${key} { ${isGenerativeValue(value) ? "ramp" : "value"}: <value>; \u2026 }`,
+          "color"
+        )
+      );
+    }
     let darkOverride;
     let hasInline = false;
     let hasParabolic;
@@ -7529,9 +8131,16 @@ function parseColorBody(body, warnings) {
         const colonIdx = stmt.indexOf(":");
         if (colonIdx === -1) {
           for (const flag of stmt.split(/\s+/)) {
-            if (flag === "inline") hasInline = true;
-            else if (flag === "parabolic") hasParabolic = true;
-            else if (flag === "no-parabolic") hasParabolic = false;
+            if (flag === "inline") {
+              hasInline = true;
+              warnings?.push(legacySyntaxWarning("inline;", "inline: true;", "color"));
+            } else if (flag === "parabolic") {
+              hasParabolic = true;
+              warnings?.push(legacySyntaxWarning("parabolic;", "parabolic: true;", "color"));
+            } else if (flag === "no-parabolic") {
+              hasParabolic = false;
+              warnings?.push(legacySyntaxWarning("no-parabolic;", "parabolic: false;", "color"));
+            }
           }
           continue;
         }
@@ -7539,9 +8148,9 @@ function parseColorBody(body, warnings) {
         const optVal = stmt.slice(colonIdx + 1).trim();
         if (optKey === "dark") {
           darkOverride = parseDarkOverrideValue(optVal);
-        } else if (optKey === "--ri-inline") {
+        } else if (optKey === "inline" || optKey === "--ri-inline") {
           if (optVal === "true") hasInline = true;
-        } else if (optKey === "--ri-parabolic") {
+        } else if (optKey === "parabolic" || optKey === "--ri-parabolic") {
           if (optVal === "true") hasParabolic = true;
           else if (optVal === "false") hasParabolic = false;
         }
@@ -7563,19 +8172,44 @@ function parseColorBody(body, warnings) {
   }
   return { colors, removals };
 }
+function isGenerativeValue(value) {
+  return /^-?[\d.]+\s+-?[\d.]+$/.test(value.trim());
+}
+function readNestedColorEntry(name, block, warnings) {
+  let value = null;
+  const options = [];
+  for (const statement of block.split(";")) {
+    const stmt = statement.trim();
+    if (!stmt) continue;
+    const colon = stmt.indexOf(":");
+    const key = colon === -1 ? "" : stmt.slice(0, colon).trim();
+    if (key === "ramp" || key === "value") {
+      value = stmt.slice(colon + 1).trim();
+      continue;
+    }
+    options.push(stmt);
+  }
+  if (value === null || value === "") {
+    warnings?.push(
+      `[RI-1126] @color entry "${name}" has a block but no \`ramp:\` or \`value:\` declaration, so it defines no colour. Write \`${name} { ramp: <chroma> <hue>; }\` or \`${name} { value: oklch(\u2026); }\`.`
+    );
+    return null;
+  }
+  return { value, options: options.join("; ") };
+}
 function parseColorValue(key, value, warnings) {
   const slashIdx = findPairSeparator(value);
   if (slashIdx !== -1) {
-    const light = expandColorSide(value.slice(0, slashIdx).trim());
-    const dark = expandColorSide(value.slice(slashIdx + 1).trim());
+    const light = expandColorSide(value.slice(0, slashIdx).trim(), true);
+    const dark = expandColorSide(value.slice(slashIdx + 1).trim(), true);
     return { type: "pair", light, dark };
   }
   if (/^light-dark\s*\(/.test(value)) {
     const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")")).trim();
     const commaIdx = topLevelIndexOf(inner, ",");
     if (commaIdx !== -1) {
-      const light = expandColorSide(inner.slice(0, commaIdx).trim());
-      const dark = expandColorSide(inner.slice(commaIdx + 1).trim());
+      const light = expandColorSide(inner.slice(0, commaIdx).trim(), true);
+      const dark = expandColorSide(inner.slice(commaIdx + 1).trim(), true);
       return { type: "pair", light, dark };
     }
   }
@@ -7847,6 +8481,10 @@ function applyFaceOptions(face, entries, slot, warnings) {
     }
   }
 }
+function unwrapURL(value) {
+  const match = /^url\(\s*(.*?)\s*\)$/i.exec(value.trim());
+  return stripQuotes(match ? match[1] : value);
+}
 var LEGACY_METRICS_KEYS = /* @__PURE__ */ new Set([
   "metricsFallback",
   "sizeAdjust",
@@ -7864,6 +8502,22 @@ function parseSlotBody(body, slot, warnings) {
       continue;
     }
     if (entry.fragment) {
+      if (entry.value === "face" && entry.block !== void 0) {
+        let src = "";
+        const own = [];
+        for (const [k, v] of parseKeyValueBody(entry.block, warnings, "font").entries) {
+          if (k === "src") src = unwrapURL(v);
+          else own.push([k, v]);
+        }
+        if (src === "") {
+          warnings?.push(
+            `[RI-1217] @font slot "${slot}" has a \`face { \u2026 }\` block with no \`src:\` \u2014 write \`face { src: url("/fonts/\u2026"); }\`. The entry was ignored.`
+          );
+        } else {
+          out.faces.push({ src, entries: own });
+        }
+        continue;
+      }
       if (entry.value === "@face" && entry.block !== void 0) {
         warnDeprecated(warnings, slot, "`@face { src: \u2026; }`", "use `face: <src> { \u2026 }`");
         let src = "";
@@ -8092,11 +8746,45 @@ function buildSlot(slot, preambleText, blockBody, warnings) {
   }
   return config;
 }
+function readNestedSlot(slot, block, warnings) {
+  let family = null;
+  let from = null;
+  const rest = [];
+  for (const entry of scanEntries(stripCSSComments(block), { newlineTerminates: false })) {
+    if (entry.block === void 0 && entry.key === "family") {
+      family = entry.value;
+      continue;
+    }
+    if (entry.block === void 0 && entry.key === "from") {
+      from = entry.value;
+      continue;
+    }
+    rest.push(block.slice(entry.start, entry.end).trim());
+  }
+  if (family === null || family === "") {
+    warnings?.push(
+      `[RI-1221] @font slot "${slot}" has a block but no \`family:\` declaration, so it names no font. Write \`${slot} { family: "<Family>", <fallback>; }\` \u2014 or \`family: system;\` for the system stack.`
+    );
+    return null;
+  }
+  return {
+    preamble: from === null ? family : `${family} from ${from}`,
+    body: rest.join("\n")
+  };
+}
 function parseNestedFontBlock(body, warnings) {
   const cleanedBody = stripCSSComments(body);
   const configs = [];
   for (const entry of scanEntries(cleanedBody, { newlineTerminates: false })) {
-    if (entry.removal || entry.fragment) continue;
+    if (entry.removal) continue;
+    if (entry.fragment) {
+      if (entry.block === void 0) continue;
+      const nested = readNestedSlot(entry.value, entry.block, warnings);
+      if (nested !== null) {
+        configs.push(buildSlot(entry.value, nested.preamble, nested.body, warnings));
+      }
+      continue;
+    }
     if (entry.unclosedBlock) break;
     if (!entry.key) continue;
     if (configs.length >= MAX_FONT_CONFIGS) {
@@ -8106,6 +8794,13 @@ function parseNestedFontBlock(body, warnings) {
       break;
     }
     if (entry.block !== void 0) {
+      warnings?.push(
+        legacySyntaxWarning(
+          `${entry.key}: <family> { \u2026 }`,
+          `${entry.key} { family: <family>; \u2026 }`,
+          "font"
+        )
+      );
       configs.push(buildSlot(entry.key, entry.value, entry.block, warnings));
     } else if (entry.value) {
       configs.push(buildSlot(entry.key, entry.value, void 0, warnings));
@@ -8145,23 +8840,122 @@ function parseSpacingBody(body) {
     base
   };
 }
-function parseAnimateBody(body) {
+function parseAnimateBody(body, warnings) {
   const animations = {};
   const removals = [];
   const cleaned = stripCSSComments(body);
   for (const entry of scanEntries(cleaned, { newlineTerminates: false })) {
     if (entry.removal) {
       removals.push(entry.key);
+      if (entry.legacyRemoval) {
+        warnings?.push(legacySyntaxWarning(`!${entry.key};`, `${entry.key}: initial;`, "animate"));
+      }
       continue;
     }
     if (entry.block === void 0) continue;
+    if (entry.fragment) {
+      const parsed = parseNestedAnimation(entry.value, entry.block, warnings);
+      if (parsed !== null) animations[entry.value] = parsed;
+      continue;
+    }
     if (!IDENT_KEY_RE.test(entry.key)) continue;
-    animations[entry.key] = { shorthand: entry.value, keyframes: entry.block };
+    warnings?.push(
+      legacySyntaxWarning(
+        `${entry.key}: <animation> { \u2026 }`,
+        `${entry.key} { animation: <animation>; @keyframes ${entry.key} { \u2026 } }`,
+        "animate"
+      )
+    );
+    animations[entry.key] = {
+      shorthand: entry.value,
+      keyframes: normalizeKeyframes(entry.block)
+    };
+  }
+  for (const [name, definition] of Object.entries(animations)) {
+    if (definition.shorthand.split(/\s+/).includes(name)) continue;
+    warnings?.push(
+      `[RI-1049] @animate entry "${name}" has the shorthand "${definition.shorthand}", which never names "${name}" \u2014 so \`animate-${name}\` sets no animation-name and the keyframes never run. Write \`${name} ${definition.shorthand}\`.`
+    );
   }
   return { animations, removals };
 }
-function parseFluidBody(body) {
-  const { entries } = parseKeyValueBody(body);
+function parseNestedAnimation(name, block, warnings) {
+  if (!IDENT_KEY_RE.test(name)) return null;
+  let shorthand = "";
+  let keyframes = null;
+  let keyframesName = null;
+  let rest = "";
+  let at = 0;
+  const cleaned = stripCSSComments(block);
+  for (const rule of scanTopLevelAtRules(cleaned)) {
+    rest += cleaned.slice(at, rule.start);
+    at = rule.end;
+    if (rule.name !== "keyframes" || rule.body === null) continue;
+    keyframes = rule.body.trim();
+    keyframesName = rule.prelude.trim();
+  }
+  rest += cleaned.slice(at);
+  for (const [key, value] of parseKeyValueBody(rest).entries) {
+    if (key === "animation") shorthand = value;
+  }
+  if (keyframes === null) {
+    warnings?.push(
+      `[RI-1047] @animate entry "${name}" has no @keyframes block, so it defines no animation. Add \`@keyframes ${name} { \u2026 }\` inside it \u2014 or, if a custom utility was intended, move the block out of @animate.`
+    );
+    return null;
+  }
+  if (shorthand === "") {
+    warnings?.push(
+      `[RI-1047] @animate entry "${name}" has @keyframes but no \`animation:\` declaration, so nothing says how to run them. Add \`animation: ${keyframesName || name} <duration> <timing> <iteration>;\`.`
+    );
+    return null;
+  }
+  if (keyframesName !== null && keyframesName !== "" && keyframesName !== name) {
+    warnings?.push(
+      `[RI-1048] @animate entry "${name}" holds \`@keyframes ${keyframesName}\`, but the emitted keyframes are named after the entry \u2014 so "${keyframesName}" would never exist. Rename one of them to match. To reuse another entry's keyframes, name them here too.`
+    );
+    return null;
+  }
+  return { shorthand, keyframes: normalizeKeyframes(keyframes) };
+}
+function normalizeKeyframes(body) {
+  const lines = body.split("\n");
+  if (lines.length < 2) return body;
+  let common = Number.POSITIVE_INFINITY;
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "") continue;
+    common = Math.min(common, line.length - line.trimStart().length);
+  }
+  if (!Number.isFinite(common) || common === 0) return body;
+  return [lines[0], ...lines.slice(1).map((line) => line.slice(common))].join("\n");
+}
+function scanTopLevelAtRules(css) {
+  const out = [];
+  for (let i = 0; i < css.length; i++) {
+    if (css[i] !== "@") continue;
+    let nameEnd = i + 1;
+    while (nameEnd < css.length && /[\w-]/.test(css[nameEnd])) nameEnd++;
+    const name = css.slice(i + 1, nameEnd);
+    if (!name) continue;
+    let j = nameEnd;
+    while (j < css.length && css[j] !== "{" && css[j] !== ";") j++;
+    if (j >= css.length) break;
+    const prelude = css.slice(nameEnd, j).trim();
+    if (css[j] === ";") {
+      out.push({ name, prelude, body: null, start: i, end: j + 1 });
+      i = j;
+      continue;
+    }
+    const close = findClosingBrace(css, j);
+    if (close === -1) break;
+    out.push({ name, prelude, body: css.slice(j + 1, close), start: i, end: close + 1 });
+    i = close;
+  }
+  return out;
+}
+var DEAD_FLUID_KEYWORDS = /* @__PURE__ */ new Set(["parabolic", "no-parabolic", "shift", "no-shift"]);
+function parseFluidBody(body, warnings) {
+  const { entries } = parseKeyValueBody(body, warnings, "fluid");
   const result = {};
   for (const [key, value] of entries) {
     if (key === "min") result.min = value;
@@ -8169,6 +8963,16 @@ function parseFluidBody(body) {
     if (key === "unit") result.unit = value;
     if (key === "multiplier") result.multiplier = value;
   }
+  if (warnings) {
+    for (const statement of stripCSSComments(body).split(/[;\n]/)) {
+      const word = statement.trim();
+      if (DEAD_FLUID_KEYWORDS.has(word)) {
+        warnings.push(
+          `[RI-1046] \`${word};\` in @fluid is a deprecated spelling that never had an effect \u2014 @fluid takes min, max, unit and multiplier, and nothing else. Delete it. The bare keyword is not valid CSS, so a formatter cannot read the file.`
+        );
+      }
+    }
+  }
   return result;
 }
 function parsePreflightDirective(body, modifier, base) {
@@ -8231,12 +9035,19 @@ function parseUtilityDirective(body, modifier, warnings) {
   if (!isValidUtilityName(name, warnings)) return null;
   return { name, functional, body: normalizedBody };
 }
+var ANIMATION_DECL_RE = /(^|[;{\s])animation(?:-name)?\s*:/;
 function extractUtilityBlocks(body, prefix, newlineTerminates, warnings) {
   const cleaned = stripCSSComments(body);
   const utilities = [];
   const cuts = [];
   for (const entry of scanEntries(cleaned, { newlineTerminates })) {
     if (!entry.fragment || entry.block === void 0) continue;
+    if (hasTopLevelKeyframes(entry.block)) continue;
+    if (prefix === "animate" && ANIMATION_DECL_RE.test(entry.block)) {
+      warnings?.push(
+        `[RI-1047] @animate entry "${entry.value}" sets \`animation\` but has no @keyframes block, so it was read as a custom utility named "animate-${entry.value}" and the animation it names is never defined. Add \`@keyframes \u2026 { \u2026 }\` inside the entry, or move the block out of @animate if a utility was intended.`
+      );
+    }
     const util = parseUtilityDirective(entry.block, `${prefix}-${entry.value}`, warnings);
     if (util) utilities.push(util);
     cuts.push([entry.start, entry.end]);
@@ -8470,7 +9281,11 @@ function mergeWithRemovals(defaults, overrides, removals, warnings, directiveNam
   for (const key of removals) {
     if (!Object.hasOwn(result, key) && warnings) {
       warnings.push(
-        `[RI-1103] Invalid removal "!${key}" in @${directiveName ?? "unknown"} \u2014 key "${key}" does not exist in defaults.`
+        // Spelling-neutral: three forms produce a removal (`key: initial`,
+        // the deprecated `!key`, and the plugin's `--ri-rm`), and naming
+        // one of them in the message sends a reader looking for text that
+        // is not in their file.
+        `[RI-1103] Invalid removal of "${key}" in @${directiveName ?? "unknown"} \u2014 it does not exist, so there is nothing to remove.`
       );
     }
     delete result[key];
@@ -8544,6 +9359,19 @@ function applyFluidDirective(target, parsed, directiveName, warnings, options =
   }
   validateFluidRange(target, directiveName, warnings);
 }
+function parseDarkVariant(value, warnings) {
+  if (value === "media") return { kind: "media" };
+  if (value === "appearance") return { kind: "appearance" };
+  const selector = /^selector\s*\((.*)\)$/s.exec(value);
+  if (selector) {
+    const inner = selector[1].trim();
+    if (inner) return { kind: "selector", selector: inner };
+  }
+  warnings.push(
+    `[RI-1111] Invalid @color dark variant "${value}" \u2014 expected "media", "appearance", or "selector(<sel>)", as in "selector(.dark)".`
+  );
+  return null;
+}
 function validateColorAliases(theme) {
   for (const [name, def] of Object.entries(theme.colors)) {
     if (def.type !== "alias") continue;
@@ -8567,11 +9395,26 @@ function validateColorAliases(theme) {
     }
   }
 }
-var SHADOW_ALIAS_RE = /^shadow-([a-z0-9]+(?:-[a-z0-9]+)*)$/;
-function resolveShadowAliases(theme) {
-  const aliases = /* @__PURE__ */ new Map();
-  for (const [name, value] of Object.entries(theme.shadows)) {
-    const match = SHADOW_ALIAS_RE.exec(value);
+function validateGenerativeColorRefs(theme) {
+  for (const [name, def] of Object.entries(theme.colors)) {
+    const values = def.type === "explicit" ? [def.value] : def.type === "pair" ? [def.light, def.dark] : [];
+    for (const value of values) {
+      for (const match of value.matchAll(BARE_COLOR_VAR_RE)) {
+        const referenced = theme.colors[match[1]];
+        if (referenced?.type !== "generative") continue;
+        theme.warnings.push(
+          `[RI-1109] @color "${name}" references "${match[1]}" with no stop. "${match[1]}" is a generative palette, which defines --color-${match[1]}-<stop> and no bare --color-${match[1]}. Name a stop, as in "${match[1]}-500".`
+        );
+      }
+    }
+  }
+}
+var BARE_COLOR_VAR_RE = /var\(--color-([a-z][\w-]*?)\s*[,)]/gi;
+var SHADOW_ALIAS_RE = /^shadow-([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+function resolveShadowAliases(theme) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(theme.shadows)) {
+    const match = SHADOW_ALIAS_RE.exec(value);
     if (match) aliases.set(name, match[1]);
   }
   for (const [name, target] of aliases) {
@@ -8768,9 +9611,12 @@ function resolveDirectives(directives, attribution) {
             } else if (k === "hue-shift") {
               const n = Number.parseFloat(v);
               if (!Number.isNaN(n)) theme.darkConfig.hueShift = n;
+            } else if (k === "variant") {
+              const strategy = parseDarkVariant(v, theme.warnings);
+              if (strategy) theme.darkConfig.variant = strategy;
             } else {
               theme.warnings.push(
-                `[RI-1104] Unknown @color dark option "${k}" \u2014 supported: mode, chroma-boost, hue-shift.`
+                `[RI-1104] Unknown @color dark option "${k}" \u2014 supported: mode, chroma-boost, hue-shift, variant.`
               );
             }
           }
@@ -8842,6 +9688,11 @@ function resolveDirectives(directives, attribution) {
           })) {
             if (entry.removal) {
               removals.push(entry.key);
+              if (entry.legacyRemoval) {
+                theme.warnings.push(
+                  legacySyntaxWarning(`!${entry.key};`, `${entry.key}: initial;`, "rounded")
+                );
+              }
               continue;
             }
             if (entry.fragment) continue;
@@ -8906,7 +9757,8 @@ function resolveDirectives(directives, attribution) {
       case "animate": {
         warnIgnoredModifier("animate", directive.modifier, theme.warnings);
         const { animations: parsedAnims, removals: animRemovals } = parseAnimateBody(
-          directive.body
+          directive.body,
+          theme.warnings
         );
         theme.animations = mergeWithRemovals(
           theme.animations,
@@ -8918,7 +9770,7 @@ function resolveDirectives(directives, attribution) {
         break;
       }
       case "fluid": {
-        const parsed = parseFluidBody(directive.body);
+        const parsed = parseFluidBody(directive.body, theme.warnings);
         const targetName = directive.modifier?.trim();
         if (!targetName) {
           applyFluidDirective(theme.fluid, parsed, "@fluid", theme.warnings, {
@@ -9018,6 +9870,7 @@ function resolveDirectives(directives, attribution) {
     }
   }
   validateColorAliases(theme);
+  validateGenerativeColorRefs(theme);
   resolveShadowAliases(theme);
   theme.fonts = dedupeLastWins(
     theme.fonts,
@@ -9320,6 +10173,66 @@ var OutputMap = class {
   }
 };
 var BODY_TOKEN_RE = /\S+/g;
+function normalizeApplyParenGroups(input) {
+  if (!input.includes("(")) return input;
+  let out = null;
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] === "[") {
+      while (i < input.length && input[i] !== "]") i++;
+      continue;
+    }
+    if (input[i] !== "(") continue;
+    if (i < 2 || input[i - 1] !== ":") continue;
+    if (!isGroupSegmentCharCode(input.charCodeAt(i - 2))) continue;
+    const close = matchingParen(input, i);
+    if (close === -1) continue;
+    out ??= [...input];
+    out[i] = "{";
+    out[close] = "}";
+  }
+  return out === null ? input : out.join("");
+}
+function matchingParen(input, open) {
+  let depth = 0;
+  for (let i = open; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "[") {
+      while (i < input.length && input[i] !== "]") {
+        if (input[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+var LEGACY_APPLY_GROUP_RE = /[\w@-]+:\{/;
+function expandApplyBodyGroups(input, warnings, path) {
+  if (LEGACY_APPLY_GROUP_RE.test(input)) {
+    warnings?.push(
+      `[RI-1046] \`@apply variant:{ \u2026 }\`${path ? ` in ${path}` : ""} is a deprecated spelling \u2014 write \`@apply variant:( \u2026 )\` instead. A brace opens a block to every CSS parser, so the old form makes the file unreadable to a formatter; it still works, and will be removed at 1.0.`
+    );
+  }
+  return expandVariantGroups(normalizeApplyParenGroups(input), warnings, path);
+}
 function expandVariantGroups(input, warnings, path) {
   return expandVariantGroupsCore(input, warnings, null, path);
 }
@@ -9472,8 +10385,8 @@ function expandVariantGroupsCore(input, warnings, map, path) {
   return parts.join("");
 }
 var APPLY_AT_RULE_RE = /@(?:apply|a)\s+/g;
-function expandApplyGroups(css, warnings, path) {
-  if (!css.includes("{") || !css.includes("@")) return css;
+function expandGroupsInStylesheet(css, warnings, path) {
+  if (!css.includes("{") && !css.includes("(") || !css.includes("@")) return css;
   APPLY_AT_RULE_RE.lastIndex = 0;
   let match = APPLY_AT_RULE_RE.exec(css);
   if (match === null) return css;
@@ -9493,8 +10406,8 @@ function expandApplyGroups(css, warnings, path) {
       i++;
     }
     const body = css.slice(bodyStart, i);
-    if (body.includes("{")) {
-      const expanded = expandVariantGroups(body, warnings, path);
+    if (body.includes("{") || body.includes("(")) {
+      const expanded = expandApplyBodyGroups(body, warnings, path);
       if (expanded !== body) {
         out.push(css.slice(lastEnd, bodyStart));
         out.push(expanded);
@@ -9882,7 +10795,9 @@ var CandidateCollector = class {
 var BOUNDARY = /(?:^|[\s"'`{;:,=+(|])/.source;
 var NEGATIVE = /-?/.source;
 var IMPORTANT_SUFFIX = /!?/.source;
-var VARIANT_SEGMENT = /(?:[\w.@-]+(?:\[[^\]]*\])?|\[[^\]]*\]):/.source;
+var VARIANT_BRACKET = /\[(?:[^[\]]|\[[^\]]*\])*\]/.source;
+var VARIANT_NAME_SUFFIX = /(?:\/[\w-]+)?/.source;
+var VARIANT_SEGMENT = `(?:[\\w.@-]+(?:${VARIANT_BRACKET})?|${VARIANT_BRACKET})${VARIANT_NAME_SUFFIX}:`;
 var VARIANT_PREFIX = `(?:${VARIANT_SEGMENT})*`;
 var UTILITY_VALUE = /[\w.@-]+(?:\[[^\]]*\]|(?<=-)\([^)]*\))?(?:\/(?:[\w.]+|\[[^\]]*\]|\([^)]*--[^)]*\)))?/.source;
 var VARIANT_GROUP = /[\w.@-]+:\{[^}]*\}/.source;
@@ -9901,7 +10816,7 @@ var CLASS_HELPERS = [
   "twJoin",
   "twMerge"
 ];
-var VARIANT_HELPERS = ["cva", "tv"];
+var VARIANT_HELPERS = ["cva", "tv", "recipe"];
 var CLASS_HELPER_NAMES = Object.freeze([...CLASS_HELPERS]);
 var VARIANT_HELPER_NAMES = Object.freeze([...VARIANT_HELPERS]);
 var CLASS_HELPERS_CALL_RE = new RegExp(`\\b(?:${CLASS_HELPERS.join("|")})\\s*\\(`, "g");
@@ -9910,8 +10825,9 @@ var CLASS_MAP_CALL_RE = /\bclassMap\s*\(/g;
 var TRANSLATE_SCRATCH = new Int32Array(4);
 var BRACKET_SPAN_RE = /\[[^\]]*\]/g;
 var HAS_UPPERCASE_RE = /[A-Z]/;
-var BRACKET_WHITESPACE_RE = /\[[^\]]*\s+[^\]]*\]/;
-var INDEX_ACCESS_RE = /\[\d*\]$/;
+var BRACKET_WHITESPACE_RE = /\[(?:[^[\]]|\[[^\]]*\])*\s(?:[^[\]]|\[[^\]]*\])*\]/;
+var INDEX_ACCESS_RE = /[^-/]\[\d+\]$/;
+var EMPTY_BRACKET_RE = /\[\]$/;
 var PROPERTY_ACCESS_RE = /^[\w.@]+\[[^\]]+\]$/;
 function warnBracketWhitespace(warnings, cls) {
   const message = `[RI-1412] Class "${cls}" has whitespace inside its arbitrary value, so it can never match an element \u2014 class attributes, @a/@apply, and safelist() all split on whitespace. Use "_" for a space (\`bg-[url('a_b')]\` emits \`url('a b')\`) and "\\_" for a literal underscore. The class was skipped.`;
@@ -9972,16 +10888,17 @@ function scanClassTokens(sink, source, baseOffset, warnings) {
     if (!cls) continue;
     const unbanged = cls.endsWith("!") ? cls.slice(0, -1) : cls;
     const base = unbanged.replace(VARIANT_STRIP_RE, "");
+    if (BRACKET_WHITESPACE_RE.test(unbanged)) {
+      if (warnings && sink.inClassList) warnBracketWhitespace(warnings, cls);
+      continue;
+    }
     if (!base.includes("[")) {
       if (HAS_UPPERCASE_RE.test(base)) continue;
     } else {
       if (HAS_UPPERCASE_RE.test(base.replace(BRACKET_SPAN_RE, ""))) continue;
+      if (EMPTY_BRACKET_RE.test(base)) continue;
       if (INDEX_ACCESS_RE.test(base)) continue;
       if (PROPERTY_ACCESS_RE.test(base)) continue;
-      if (BRACKET_WHITESPACE_RE.test(base)) {
-        if (warnings && sink.inClassList) warnBracketWhitespace(warnings, cls);
-        continue;
-      }
     }
     if (!wantsPositions) {
       sink.add(cls, 0, 0, -1, -1);
@@ -10354,6 +11271,37 @@ function extractSvelte(sink, context, warnings) {
     warnings
   );
 }
+function astroFrontmatterEnd(content) {
+  if (!content.startsWith("---")) return 0;
+  const afterOpen = content.indexOf("\n");
+  if (afterOpen === -1) return 0;
+  for (let i = afterOpen; i !== -1; i = content.indexOf("\n", i + 1)) {
+    if (!content.startsWith("---", i + 1)) continue;
+    const lineEnd = content.indexOf("\n", i + 1);
+    const rest = lineEnd === -1 ? content.slice(i + 4) : content.slice(i + 4, lineEnd);
+    if (rest.trim() === "") return i + 4;
+  }
+  return 0;
+}
+function extractAstro(sink, context, warnings) {
+  const content = context.content;
+  sink.setOrigin?.("plain");
+  scanClassTokens(sink, content, 0, warnings);
+  sink.setOrigin?.("attribute");
+  collectAssignedValues(sink, content, /(?<![:\w-])class\s*=/g, NOOP_VISITOR, 0, warnings);
+  collectAssignedValues(sink, content, /\bclass:list\s*=/g, collectClassishExpression, 0, warnings);
+  const scriptEnd = astroFrontmatterEnd(content);
+  if (scriptEnd > 0) {
+    const script = content.slice(0, scriptEnd);
+    sink.setOrigin?.("helper");
+    collectCallArguments(sink, script, CLASS_HELPERS_CALL_RE, void 0, 0, warnings);
+    const variantMetadata = collectVariantHelperArguments(sink, script, 0, warnings);
+    collectClassMapArguments(sink, script, 0, warnings);
+    sink.setHelper?.(null);
+    pruneVariantMetadata(sink, variantMetadata, script);
+  }
+  pruneTokens(sink, NON_CLASS_IDENTIFIERS);
+}
 var EXTRACTORS = [
   {
     test: (context) => !!context.path && context.path.endsWith(".vue"),
@@ -10363,6 +11311,10 @@ var EXTRACTORS = [
     test: (context) => !!context.path && context.path.endsWith(".svelte"),
     extract: extractSvelte
   },
+  {
+    test: (context) => !!context.path && context.path.endsWith(".astro"),
+    extract: extractAstro
+  },
   {
     test: (context) => !!context.path && context.path.endsWith(".html"),
     extract: extractHTML
@@ -10439,6 +11391,352 @@ function extractClassCandidates(input, warnings) {
   return collector.finish();
 }
 
+// src/css/strip.ts
+var DIRECTIVE_AT_RULE_PATTERNS = [...EXTRACTABLE_DIRECTIVE_NAMES].map(directiveAtRulePattern);
+function buildProtectedRanges(css) {
+  const ranges = [];
+  let i = 0;
+  while (i < css.length) {
+    if (css[i] === "/" && css[i + 1] === "*") {
+      const start = i;
+      const end = css.indexOf("*/", i + 2);
+      i = end === -1 ? css.length : end + 2;
+      ranges.push([start, i]);
+      continue;
+    }
+    if (css[i] === '"' || css[i] === "'") {
+      const quote = css[i];
+      const start = i;
+      i++;
+      while (i < css.length && css[i] !== quote) {
+        if (css[i] === "\\" && i + 1 < css.length) i++;
+        i++;
+      }
+      if (i < css.length) i++;
+      ranges.push([start, i]);
+    } else {
+      i++;
+    }
+  }
+  return ranges;
+}
+function protectedRangeEnd(pos, ranges) {
+  let lo = 0;
+  let hi = ranges.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const [start, end] = ranges[mid];
+    if (pos < start) hi = mid - 1;
+    else if (pos >= end) lo = mid + 1;
+    else return end;
+  }
+  return -1;
+}
+function isInsideProtectedRange(pos, ranges) {
+  return protectedRangeEnd(pos, ranges) !== -1;
+}
+function replaceOutsideProtectedRanges(css, re, ranges) {
+  re.lastIndex = 0;
+  const parts = [];
+  let lastIdx = 0;
+  for (; ; ) {
+    const match = re.exec(css);
+    if (match === null) break;
+    const guardEnd = protectedRangeEnd(match.index, ranges);
+    if (guardEnd !== -1) {
+      re.lastIndex = guardEnd;
+      continue;
+    }
+    if (!isAtRuleBoundary(css, match.index)) {
+      re.lastIndex = match.index + 1;
+      continue;
+    }
+    let end = match.index + match[0].length;
+    if (isInsideProtectedRange(end - 1, ranges)) {
+      let k = end;
+      let aborted = false;
+      while (k < css.length) {
+        if (!isInsideProtectedRange(k, ranges)) {
+          const ch = css[k];
+          if (ch === ";") break;
+          if (ch === "{" || ch === "}") {
+            aborted = true;
+            break;
+          }
+        }
+        k++;
+      }
+      if (aborted) continue;
+      end = k < css.length ? k + 1 : css.length;
+      re.lastIndex = end;
+    }
+    parts.push(css.slice(lastIdx, match.index));
+    lastIdx = end;
+  }
+  parts.push(css.slice(lastIdx));
+  return parts.join("");
+}
+function stripBalancedBlocks(css, re, protectedRanges) {
+  re.lastIndex = 0;
+  const ranges = [];
+  for (; ; ) {
+    const match = re.exec(css);
+    if (match === null) break;
+    const start = match.index;
+    const guardEnd = protectedRangeEnd(start, protectedRanges);
+    if (guardEnd !== -1) {
+      re.lastIndex = guardEnd;
+      continue;
+    }
+    if (!isAtRuleBoundary(css, start)) {
+      re.lastIndex = start + 1;
+      continue;
+    }
+    let braceIdx = css.indexOf("{", start);
+    while (braceIdx !== -1 && isInsideProtectedRange(braceIdx, protectedRanges)) {
+      braceIdx = css.indexOf("{", braceIdx + 1);
+    }
+    const preludeEnd = braceIdx === -1 ? css.length : braceIdx;
+    let semiIdx = -1;
+    for (let k = start; k < preludeEnd; k++) {
+      if (css[k] === ";" && !isInsideProtectedRange(k, protectedRanges)) {
+        semiIdx = k;
+        break;
+      }
+    }
+    if (semiIdx !== -1) {
+      ranges.push([start, semiIdx + 1]);
+      re.lastIndex = semiIdx + 1;
+      continue;
+    }
+    if (braceIdx === -1) {
+      ranges.push([start, css.length]);
+      break;
+    }
+    let depth = 1;
+    let j = braceIdx + 1;
+    while (j < css.length && depth > 0) {
+      const ch = css[j];
+      if (ch === '"' || ch === "'") {
+        const quote = ch;
+        j++;
+        while (j < css.length && css[j] !== quote) {
+          if (css[j] === "\\" && j + 1 < css.length) j++;
+          j++;
+        }
+        j++;
+        continue;
+      }
+      if (ch === "/" && css[j + 1] === "*") {
+        const end = css.indexOf("*/", j + 2);
+        j = end === -1 ? css.length : end + 2;
+        continue;
+      }
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+      j++;
+    }
+    ranges.push([start, j]);
+    re.lastIndex = j;
+  }
+  if (ranges.length === 0) return css;
+  const parts = [];
+  let lastEnd = 0;
+  for (const [start, end] of ranges) {
+    parts.push(css.slice(lastEnd, start));
+    lastEnd = end;
+  }
+  parts.push(css.slice(lastEnd));
+  return parts.join("");
+}
+var ALL_SEMI_DIRECTIVES_RE = new RegExp(
+  DIRECTIVE_AT_RULE_PATTERNS.map((p) => `${p}[^{;]*;`).join("|"),
+  "g"
+);
+var ALL_BRACE_DIRECTIVES_RE = new RegExp(
+  DIRECTIVE_AT_RULE_PATTERNS.map((p) => `${p}[^{]*{`).join("|"),
+  "g"
+);
+var RI_IMPORT_RE = new RegExp(
+  `@import\\s+(?:url\\(\\s*)?["'](?:${RI_IMPORT_SPECIFIER_ALTERNATION})["']\\s*\\)?[^;]*;`,
+  "g"
+);
+var NO_JOIN_NEEDED = /* @__PURE__ */ new Set([";", ",", "(", ")", "{", "}", ":"]);
+function stripCSSComments2(css) {
+  if (!css.includes("/*")) return css;
+  const parts = [];
+  let cursor = 0;
+  for (const [start, end] of buildProtectedRanges(css)) {
+    if (css[start] !== "/") continue;
+    if (css[start + 2] === "!") continue;
+    const before = css[start - 1];
+    const after = css[end];
+    const welds = before !== void 0 && after !== void 0 && !/\s/.test(before) && !/\s/.test(after) && !NO_JOIN_NEEDED.has(before) && !NO_JOIN_NEEDED.has(after);
+    parts.push(css.slice(cursor, start), welds ? " " : "");
+    cursor = end;
+  }
+  if (cursor === 0) return css;
+  parts.push(css.slice(cursor));
+  return parts.join("").replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n");
+}
+function stripRIDirectives(css) {
+  let currentRanges = buildProtectedRanges(css);
+  let result = replaceOutsideProtectedRanges(css, RI_IMPORT_RE, currentRanges);
+  if (result !== css) {
+    currentRanges = buildProtectedRanges(result);
+  }
+  const beforePhase1 = result;
+  result = replaceOutsideProtectedRanges(result, ALL_SEMI_DIRECTIVES_RE, currentRanges);
+  const dirty = result !== beforePhase1;
+  if (dirty) {
+    currentRanges = buildProtectedRanges(result);
+  }
+  result = stripBalancedBlocks(result, ALL_BRACE_DIRECTIVES_RE, currentRanges);
+  return result.trim();
+}
+
+// src/project/imports.ts
+var DEFAULT_MAX_DEPTH = 8;
+var RI_MARKER_TARGETS = new Set(RI_MARKER_IMPORT_SPECIFIERS);
+function isRemoteTarget(target) {
+  return target.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(target) || // A leading "/" is a URL path relative to the site root, not a file path.
+  target.startsWith("/");
+}
+function findStatementEnd(src, from) {
+  let i = from;
+  let depth = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      i = end === -1 ? src.length : end + 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === "\\") i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth > 0) depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      if (ch === ";") return i + 1;
+      if (ch === "{") return -1;
+    }
+    i++;
+  }
+  return src.length;
+}
+function isPackageSpecifier(target) {
+  return !target.startsWith(".");
+}
+function inlineInto(css, from, depth, ctx, inPackage) {
+  const edits = [];
+  scanAtRules(css, (name, atPos, nameEnd) => {
+    if (name !== "import") return void 0;
+    const stmtEnd = findStatementEnd(css, nameEnd);
+    if (stmtEnd === -1) return void 0;
+    const { target, nextIndex } = readImportTarget(css, nameEnd);
+    if (target === null) return stmtEnd;
+    const preludeEnd = css[stmtEnd - 1] === ";" ? stmtEnd - 1 : stmtEnd;
+    const tail = css.slice(Math.min(nextIndex, preludeEnd), preludeEnd).trim();
+    if (RI_MARKER_TARGETS.has(target)) {
+      if (depth > 0) edits.push({ start: atPos, end: stmtEnd, text: "" });
+      return stmtEnd;
+    }
+    if (isRemoteTarget(target)) return stmtEnd;
+    if (tail !== "") {
+      ctx.warnings.push(
+        `[RI-1045] Conditional @import "${target}" (${tail}) was left in place; directives inside it are not read. Move the directives to an unconditional @import.`
+      );
+      return stmtEnd;
+    }
+    if (ctx.exhausted) return stmtEnd;
+    if (depth >= ctx.maxDepth) {
+      ctx.warnings.push(
+        `[RI-1043] @import "${target}" nests deeper than ${ctx.maxDepth} levels and was left in place. Flatten the import chain.`
+      );
+      return stmtEnd;
+    }
+    const resolved = ctx.resolve(target, from);
+    if (resolved === null) {
+      ctx.warnings.push(
+        `[RI-1041] Could not resolve @import "${target}"${from ? ` from "${from}"` : ""}. The at-rule was left in place and its directives were not read. Check the path, or install the package.`
+      );
+      return stmtEnd;
+    }
+    if (ctx.stack.has(resolved.path)) {
+      ctx.warnings.push(
+        `[RI-1042] Circular @import "${target}" \u2014 "${resolved.path}" already imports the file importing it. The repeat was dropped.`
+      );
+      edits.push({ start: atPos, end: stmtEnd, text: "" });
+      return stmtEnd;
+    }
+    if (ctx.visited.has(resolved.path)) {
+      edits.push({ start: atPos, end: stmtEnd, text: "" });
+      return stmtEnd;
+    }
+    if (ctx.bytes + resolved.content.length > ctx.maxBytes) {
+      ctx.exhausted = true;
+      ctx.warnings.push(
+        `[RI-1044] Inlined @import files exceed the ${ctx.maxBytes / 1048576} MB limit at "${target}". It and any later import were left in place. Split the stylesheet.`
+      );
+      return stmtEnd;
+    }
+    ctx.visited.add(resolved.path);
+    ctx.files.push(resolved.path);
+    ctx.bytes += resolved.content.length;
+    ctx.stack.add(resolved.path);
+    const entersPackage = !inPackage && isPackageSpecifier(target);
+    const text = inlineInto(
+      resolved.content,
+      resolved.path,
+      depth + 1,
+      ctx,
+      inPackage || entersPackage
+    );
+    ctx.stack.delete(resolved.path);
+    edits.push({ start: atPos, end: stmtEnd, text: entersPackage ? stripCSSComments2(text) : text });
+    return stmtEnd;
+  });
+  if (edits.length === 0) return css;
+  let out = "";
+  let cursor = 0;
+  for (const edit of edits) {
+    out += css.slice(cursor, edit.start) + edit.text;
+    cursor = edit.end;
+  }
+  return out + css.slice(cursor);
+}
+function inlineDirectiveImports(css, options) {
+  const ctx = {
+    resolve: options.resolve,
+    maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+    maxBytes: options.maxBytes ?? MAX_DIRECTIVE_INPUT_SIZE,
+    warnings: [],
+    files: [],
+    stack: new Set(options.from === void 0 ? [] : [options.from]),
+    visited: new Set(options.from === void 0 ? [] : [options.from]),
+    bytes: 0,
+    exhausted: false
+  };
+  const out = inlineInto(css, options.from, 0, ctx, false);
+  return { css: out, warnings: ctx.warnings, files: ctx.files };
+}
+
 // src/project/analyze.ts
 function nextLineTargets(css, spans, warnings) {
   const targets = /* @__PURE__ */ new Map();
@@ -10533,11 +11831,880 @@ function isDisabled(diagnostic, directiveIndex, suppressed, targets, capture) {
   return false;
 }
 
+// src/integrations/font-providers/metrics-data.ts
+var FONT_METRICS_TABLE = {
+  abel: [2006, -604, 0, 2048, 783, "sans-serif"],
+  alegreya: [1016, -345, 0, 1e3, 410, "serif"],
+  "anonymous pro": [1675, -373, 0, 2048, 1118, "monospace"],
+  archivo: [878, -210, 0, 1e3, 440, "sans-serif"],
+  arial: [1854, -434, 67, 2048, 913, "sans-serif"],
+  asap: [934, -212, 0, 1e3, 442, "sans-serif"],
+  barlow: [1e3, -200, 0, 1e3, 431, "sans-serif"],
+  bitter: [935, -265, 0, 1e3, 465, "serif"],
+  "bricolage grotesque": [930, -270, 0, 1e3, 470, "sans-serif"],
+  cabin: [1930, -500, 0, 2e3, 844, "sans-serif"],
+  catamaran: [1100, -540, 0, 1e3, 411, "sans-serif"],
+  chivo: [940, -250, 0, 1e3, 478, "sans-serif"],
+  "cormorant garamond": [924, -287, 0, 1e3, 394, "serif"],
+  "courier new": [1705, -615, 0, 2048, 1229, "monospace"],
+  "crimson pro": [918, -220, 0, 1024, 410, "serif"],
+  "crimson text": [972, -359, 0, 1024, 405, "serif"],
+  "dm sans": [992, -310, 0, 1e3, 466, "sans-serif"],
+  "dm serif display": [1036, -335, 0, 1e3, 446, "serif"],
+  dosis: [1027, -237, 0, 1e3, 377, "sans-serif"],
+  "eb garamond": [1007, -298, 0, 1e3, 385, "serif"],
+  epilogue: [1580, -470, 0, 2e3, 990, "sans-serif"],
+  "exo 2": [999, -201, 0, 1e3, 455, "sans-serif"],
+  figtree: [950, -250, 0, 1e3, 449, "sans-serif"],
+  "fira code": [1980, -644, 0, 2e3, 1200, "monospace"],
+  "fira sans": [935, -265, 0, 1e3, 458, "sans-serif"],
+  fraunces: [1956, -510, 0, 2e3, 938, "serif"],
+  gabarito: [940, -260, 0, 1e3, 442, "display"],
+  "geist mono": [1005, -295, 0, 1e3, 600, "monospace"],
+  geist: [1005, -295, 0, 1e3, 467, "sans-serif"],
+  georgia: [1878, -449, 0, 2048, 913, "serif"],
+  heebo: [2146, -862, 0, 2048, 912, "sans-serif"],
+  "helvetica neue": [952, -213, 28, 1e3, 450, "sans-serif"],
+  helvetica: [1577, -471, 0, 2048, 913, "sans-serif"],
+  hind: [1055, -546, 0, 1e3, 429, "sans-serif"],
+  "ibm plex mono": [1025, -275, 0, 1e3, 600, "monospace"],
+  "ibm plex sans": [1025, -275, 0, 1e3, 451, "sans-serif"],
+  "ibm plex serif": [1025, -275, 0, 1e3, 473, "serif"],
+  inconsolata: [859, -190, 0, 1e3, 500, "monospace"],
+  "instrument sans": [970, -250, 0, 1e3, 458, "sans-serif"],
+  "instrument serif": [990, -310, 0, 1e3, 341, "serif"],
+  inter: [1984, -494, 0, 2048, 978, "sans-serif"],
+  "jetbrains mono": [1020, -300, 0, 1e3, 600, "monospace"],
+  "josefin sans": [750, -250, 0, 1e3, 456, "sans-serif"],
+  kanit: [1100, -395, 0, 1e3, 452, "sans-serif"],
+  karla: [1834, -504, 0, 2e3, 913, "sans-serif"],
+  lato: [1974, -426, 0, 2e3, 871, "sans-serif"],
+  lexend: [1e3, -250, 0, 1e3, 490, "sans-serif"],
+  "libre baskerville": [970, -270, 0, 1e3, 517, "serif"],
+  "libre franklin": [966, -246, 0, 1e3, 465, "sans-serif"],
+  lora: [1006, -274, 0, 1e3, 468, "serif"],
+  manrope: [2132, -600, 0, 2e3, 920, "sans-serif"],
+  "maven pro": [965, -210, 0, 1e3, 462, "sans-serif"],
+  merriweather: [1968, -546, 0, 2e3, 970, "serif"],
+  montserrat: [968, -251, 0, 1e3, 503, "sans-serif"],
+  mulish: [1005, -250, 0, 1e3, 464, "sans-serif"],
+  newsreader: [1470, -530, 0, 2e3, 857, "serif"],
+  "noto sans": [1069, -293, 0, 1e3, 474, "sans-serif"],
+  "noto serif": [1069, -293, 0, 1e3, 481, "serif"],
+  "nunito sans": [1011, -353, 0, 1e3, 452, "sans-serif"],
+  nunito: [1011, -353, 0, 1e3, 452, "sans-serif"],
+  onest: [970, -305, 0, 1e3, 469, "sans-serif"],
+  "open sans": [2189, -600, 0, 2048, 960, "sans-serif"],
+  oswald: [1193, -289, 0, 1e3, 363, "sans-serif"],
+  outfit: [1e3, -260, 0, 1e3, 445, "sans-serif"],
+  overpass: [1766, -766, 0, 2e3, 898, "sans-serif"],
+  oxygen: [2103, -483, 0, 2048, 923, "sans-serif"],
+  "playfair display": [1082, -251, 0, 1e3, 452, "serif"],
+  "plus jakarta sans": [1038, -222, 0, 1e3, 468, "sans-serif"],
+  poppins: [1050, -350, 100, 1e3, 500, "sans-serif"],
+  "pt sans": [1018, -276, 0, 1e3, 431, "sans-serif"],
+  "pt serif": [1039, -286, 0, 1e3, 448, "serif"],
+  "public sans": [1900, -450, 0, 2e3, 935, "sans-serif"],
+  quicksand: [1e3, -250, 0, 1e3, 465, "sans-serif"],
+  raleway: [940, -234, 0, 1e3, 463, "sans-serif"],
+  "red hat display": [1018, -305, 0, 1e3, 442, "sans-serif"],
+  "red hat text": [1018, -305, 0, 1e3, 447, "sans-serif"],
+  "roboto condensed": [1900, -500, 0, 2048, 811, "sans-serif"],
+  "roboto flex": [1900, -500, 0, 2048, 908, "sans-serif"],
+  "roboto mono": [2146, -555, 0, 2048, 1229, "monospace"],
+  "roboto slab": [2146, -555, 0, 2048, 972, "serif"],
+  roboto: [1900, -500, 0, 2048, 911, "sans-serif"],
+  rubik: [935, -250, 0, 1e3, 468, "sans-serif"],
+  "schibsted grotesk": [2e3, -528, 0, 2048, 954, "sans-serif"],
+  "segoe ui": [2210, -514, 0, 2048, 908, "sans-serif"],
+  sora: [970, -290, 0, 1e3, 507, "sans-serif"],
+  "source code pro": [984, -273, 0, 1e3, 600, "monospace"],
+  "source sans 3": [1024, -400, 0, 1e3, 418, "sans-serif"],
+  "source serif 4": [1036, -335, 0, 1e3, 479, "serif"],
+  "space grotesk": [984, -292, 0, 1e3, 489, "sans-serif"],
+  "space mono": [1120, -361, 0, 1e3, 612, "monospace"],
+  spectral: [1059, -463, 0, 1e3, 446, "serif"],
+  tahoma: [2049, -423, 0, 2048, 917, "sans-serif"],
+  "times new roman": [1825, -443, 87, 2048, 832, "serif"],
+  "titillium web": [1133, -388, 0, 1e3, 421, "sans-serif"],
+  "trebuchet ms": [1923, -455, 0, 2048, 934, "sans-serif"],
+  "ubuntu mono": [830, -170, 0, 1e3, 500, "monospace"],
+  ubuntu: [932, -189, 28, 1e3, 455, "sans-serif"],
+  urbanist: [1900, -500, 0, 2e3, 883, "sans-serif"],
+  "varela round": [918, -286, 0, 1e3, 478, "sans-serif"],
+  verdana: [2059, -430, 0, 2048, 1049, "sans-serif"],
+  "victor mono": [1100, -250, 0, 1e3, 600, "monospace"],
+  vollkorn: [952, -441, 0, 1e3, 438, "serif"],
+  "work sans": [930, -243, 0, 1e3, 499, "sans-serif"],
+  "zilla slab": [944, -256, 0, 1e3, 434, "serif"]
+};
+
+// src/integrations/font-providers/metrics.ts
+var CATEGORY_FALLBACK = {
+  "sans-serif": "Arial",
+  serif: "Times New Roman",
+  monospace: "Courier New"
+};
+function lookupFontMetrics(family) {
+  return FONT_METRICS_TABLE[family.trim().toLowerCase()];
+}
+var round4 = (n) => Math.round(n * 1e4) / 1e4;
+function computeFallbackMetrics(fallbackName, font, fallbackFont) {
+  const [ascent, descent, lineGap, unitsPerEm, xWidthAvg] = font;
+  const [, , , fbUnitsPerEm, fbXWidthAvg] = fallbackFont;
+  const sizeAdjust = xWidthAvg / unitsPerEm / (fbXWidthAvg / fbUnitsPerEm);
+  return {
+    fallback: fallbackName,
+    sizeAdjust: round4(sizeAdjust * 100),
+    ascent: round4(ascent / unitsPerEm / sizeAdjust * 100),
+    descent: round4(Math.abs(descent) / unitsPerEm / sizeAdjust * 100),
+    lineGap: round4(lineGap / unitsPerEm / sizeAdjust * 100)
+  };
+}
+function resolveAutoMetrics(family, fallbackStack, explicitFallback) {
+  const font = lookupFontMetrics(family);
+  if (!font) return null;
+  const fallbackName = explicitFallback ?? fallbackStack.find((f) => lookupFontMetrics(f)) ?? CATEGORY_FALLBACK[font[5]] ?? "Arial";
+  const fallbackFont = lookupFontMetrics(fallbackName);
+  if (!fallbackFont) return null;
+  return computeFallbackMetrics(fallbackName, font, fallbackFont);
+}
+
+// src/integrations/font-providers/emit.ts
+var SYSTEM_STACKS = Object.freeze({
+  sans: 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
+  serif: 'ui-serif, Georgia, Cambria, "Times New Roman", Times, serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
+  mono: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"'
+});
+function getFallbackStack(slot) {
+  if (!SYSTEM_STACKS[slot] && isRIDebug()) {
+    console.warn(`[RI-DEBUG] Unknown font slot "${slot}" \u2014 falling back to sans stack.`);
+  }
+  return SYSTEM_STACKS[slot] || SYSTEM_STACKS.sans;
+}
+function googleFontsUrl(family, face) {
+  const encodedFamily = encodeURIComponent(family).replace(/%20/g, "+");
+  let axisParam;
+  if (face.weight.includes(",")) {
+    const weights = face.weight.split(",").map((w) => w.trim());
+    if (face.style.includes("italic")) {
+      const tuples = weights.flatMap((w) => [`0,${w}`, `1,${w}`]);
+      axisParam = `ital,wght@${tuples.join(";")}`;
+    } else {
+      axisParam = `wght@${weights.join(";")}`;
+    }
+  } else if (face.weight.includes(" ")) {
+    const range = face.weight.replace(" ", "..");
+    axisParam = face.style.includes("italic") ? `ital,wght@0,${range};1,${range}` : `wght@${range}`;
+  } else {
+    const w = face.weight || "400";
+    axisParam = face.style.includes("italic") ? `ital,wght@0,${w};1,${w}` : `wght@${w}`;
+  }
+  const display = face.display || "swap";
+  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:${axisParam}&display=${display}`;
+}
+function escapeFontFamily(name) {
+  return name.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\n/g, "\\a ").replace(/\r/g, "\\d ");
+}
+function generateFallbackFontFace(family, metrics) {
+  const safeFamily = escapeFontFamily(family);
+  return `@font-face {
+  font-family: "${safeFamily} Fallback";
+  src: local("${escapeFontFamily(metrics.fallback)}");
+  size-adjust: ${metrics.sizeAdjust}%;
+  ascent-override: ${metrics.ascent}%;
+  descent-override: ${metrics.descent}%;
+  line-gap-override: ${metrics.lineGap}%;
+}`;
+}
+var FONT_FORMAT_MIME = {
+  woff2: "font/woff2",
+  woff: "font/woff",
+  truetype: "font/ttf",
+  opentype: "font/otf"
+};
+function inferFontFormat(path) {
+  if (path.endsWith(".woff2")) return "woff2";
+  if (path.endsWith(".woff")) return "woff";
+  if (path.endsWith(".ttf")) return "truetype";
+  if (path.endsWith(".otf")) return "opentype";
+  return "woff2";
+}
+function generateWebFontFace(family, face) {
+  if (face.provider === "system" || !face.provider) return null;
+  if (face.provider === "google") {
+    return { type: "import", css: `@import url("${googleFontsUrl(family, face)}");` };
+  }
+  const safeProvider = escapeFontFamily(face.provider);
+  const format = inferFontFormat(face.provider);
+  const src = `url("${safeProvider}") format("${format}")`;
+  const declarations = [`  font-family: "${escapeFontFamily(family)}";`, `  src: ${src};`];
+  if (face.weight) declarations.push(`  font-weight: ${face.weight};`);
+  if (face.style && face.style !== "normal") declarations.push(`  font-style: ${face.style};`);
+  if (face.display) declarations.push(`  font-display: ${face.display};`);
+  if (face.unicodeRange) declarations.push(`  unicode-range: ${face.unicodeRange};`);
+  return { type: "font-face", css: `@font-face {
+${declarations.join("\n")}
+}` };
+}
+function normalizeLocalStyle(style, family, warnings) {
+  if (style.includes(" ") && !style.startsWith("oblique")) {
+    const first = style.split(/\s+/)[0];
+    warnings.push(
+      `[RI-1203] Local font "${family}" has a compound font-style "${style}" \u2014 a single @font-face takes one style. Split upright and italic into separate @face blocks (or use the italic: shorthand). Using "${first}".`
+    );
+    return first;
+  }
+  return style;
+}
+function resolveSlotMetrics(slot, warnings) {
+  const cfg = slot.metrics;
+  if (cfg === null) return null;
+  if (cfg?.sizeAdjust !== void 0) {
+    return {
+      fallback: cfg.fallback || slot.fallback[0] || "Arial",
+      sizeAdjust: cfg.sizeAdjust,
+      ascent: cfg.ascent,
+      descent: cfg.descent,
+      lineGap: cfg.lineGap
+    };
+  }
+  const resolved = resolveAutoMetrics(slot.family, slot.fallback, cfg?.fallback);
+  if (!resolved && cfg?.fallback) {
+    const missing = lookupFontMetrics(slot.family) ? cfg.fallback : slot.family;
+    warnings.push(
+      `[RI-1220] @font slot "${slot.slot}" requests metrics matching against "${cfg.fallback}", but "${missing}" is not in the built-in metrics table \u2014 no fallback @font-face was generated. Provide the four percentages explicitly (metrics: "${cfg.fallback}" <size-adjust> <ascent> <descent> <line-gap>) or use \`metrics: none\`.`
+    );
+  }
+  return resolved;
+}
+function generateFontCSS(slot) {
+  const imports = [];
+  const fontFaces = [];
+  const variables = [];
+  const warnings = [];
+  const pushFeatureVars = () => {
+    if (slot.features) variables.push(`--font-${slot.slot}--features: ${slot.features};`);
+    if (slot.variation) variables.push(`--font-${slot.slot}--variations: ${slot.variation};`);
+  };
+  if (slot.kind === "system") {
+    variables.push(`--font-${slot.slot}: ${getFallbackStack(slot.slot)};`);
+    return { imports, fontFaces, variables, warnings };
+  }
+  if (slot.kind === "manual") {
+    const fallback = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
+    const stack = [`"${escapeFontFamily(slot.family)}"`, fallback].join(", ");
+    variables.push(`--font-${slot.slot}: ${stack};`);
+    pushFeatureVars();
+    return { imports, fontFaces, variables, warnings };
+  }
+  const metrics = resolveSlotMetrics(slot, warnings);
+  if (metrics) fontFaces.push(generateFallbackFontFace(slot.family, metrics));
+  for (const face of slot.faces) {
+    if (face.provider !== "google" && !face.provider.startsWith("/") && !face.provider.startsWith("http") && !face.provider.startsWith(".")) {
+      warnings.push(
+        `[RI-1201] Unknown font provider "${face.provider}" for "${slot.family}" \u2014 supported: google, or a file path/URL.`
+      );
+      continue;
+    }
+    const emitFace = face.provider === "google" ? face : { ...face, style: normalizeLocalStyle(face.style, slot.family, warnings) };
+    const webFont = generateWebFontFace(slot.family, emitFace);
+    if (!webFont) continue;
+    if (webFont.type === "import") imports.push(webFont.css);
+    else fontFaces.push(webFont.css);
+  }
+  const fallbackStack = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
+  const safeFamily = escapeFontFamily(slot.family);
+  const stackParts = [`"${safeFamily}"`];
+  if (metrics) stackParts.push(`"${safeFamily} Fallback"`);
+  stackParts.push(fallbackStack);
+  variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
+  pushFeatureVars();
+  return { imports, fontFaces, variables, warnings };
+}
+function getFontPreloadLinks(slots) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const slot of slots) {
+    for (const face of slot.faces) {
+      if (!face.preload) continue;
+      if (face.provider === "system" || face.provider === "google" || !face.provider) continue;
+      if (seen.has(face.provider)) continue;
+      seen.add(face.provider);
+      links.push({
+        href: face.provider,
+        as: "font",
+        type: FONT_FORMAT_MIME[inferFontFormat(face.provider)],
+        crossorigin: true
+      });
+    }
+  }
+  return links;
+}
+
+// src/css/preflight.ts
+var DEFAULT_PREFLIGHT = {
+  core: true,
+  typography: true,
+  content: true,
+  forms: true,
+  interactive: true,
+  modern: true
+};
+var modules = [
+  // ── Core ─────────────────────────────────────────────────
+  {
+    name: "box-sizing",
+    category: "core",
+    css: `*, *::before, *::after {
+  box-sizing: border-box;
+}`
+  },
+  {
+    name: "margins",
+    category: "core",
+    css: `body, h1, h2, h3, h4, h5, h6, p, figure, blockquote, dl, dd, pre, ol, ul, menu {
+  margin: 0;
+}`
+  },
+  {
+    name: "borders",
+    category: "core",
+    css: `*, *::before, *::after {
+  border-width: 0;
+  border-style: solid;
+  border-color: inherit;
+}`
+  },
+  {
+    name: "root-defaults",
+    category: "core",
+    css: `:root {
+  line-height: 1.5;
+  -webkit-text-size-adjust: 100%;
+  tab-size: 4;
+}
+body {
+  line-height: inherit;
+  font-family: var(--font-sans);
+}
+code, kbd, samp, pre {
+  font-family: var(--font-mono);
+  font-size: 1em;
+}`
+  },
+  // ── Typography ───────────────────────────────────────────
+  {
+    name: "font-smoothing",
+    category: "typography",
+    css: `body {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}`
+  },
+  {
+    name: "font-inherit",
+    category: "typography",
+    css: `button, input, optgroup, select, textarea {
+  font-family: inherit;
+  font-feature-settings: inherit;
+  font-variation-settings: inherit;
+  font-size: 100%;
+  font-weight: inherit;
+  line-height: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+}`
+  },
+  {
+    name: "heading-sizes",
+    category: "typography",
+    css: `h1, h2, h3, h4, h5, h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}`
+  },
+  {
+    name: "link-reset",
+    category: "typography",
+    css: `a {
+  color: inherit;
+  text-decoration: inherit;
+}`
+  },
+  // ── Content ──────────────────────────────────────────────
+  {
+    name: "media-block",
+    category: "content",
+    css: `img, svg, video, canvas, audio, iframe, embed, object {
+  display: block;
+  max-inline-size: 100%;
+}
+img, video {
+  block-size: auto;
+}`
+  },
+  {
+    name: "list-reset",
+    category: "content",
+    css: `ol, ul, menu {
+  list-style: none;
+  padding: 0;
+}`
+  },
+  {
+    name: "table-reset",
+    category: "content",
+    css: `table {
+  text-indent: 0;
+  border-color: inherit;
+  border-collapse: collapse;
+}`
+  },
+  {
+    name: "hr-reset",
+    category: "content",
+    css: `hr {
+  block-size: 0;
+  border-top-width: 1px;
+  color: inherit;
+}`
+  },
+  // ── Forms ────────────────────────────────────────────────
+  {
+    name: "button-reset",
+    category: "forms",
+    css: `button, [role="button"] {
+  cursor: pointer;
+  padding: 0;
+}
+button {
+  background-color: transparent;
+  background-image: none;
+}`
+  },
+  {
+    name: "input-reset",
+    category: "forms",
+    css: `input::placeholder, textarea::placeholder {
+  opacity: 1;
+  color: color-mix(in oklab, currentColor 48%, transparent);
+}
+input:where([type="button"], [type="reset"], [type="submit"]) {
+  -webkit-appearance: button;
+  appearance: button;
+}`
+  },
+  {
+    name: "textarea-reset",
+    category: "forms",
+    css: `textarea {
+  resize: vertical;
+}`
+  },
+  {
+    name: "fieldset-reset",
+    category: "forms",
+    css: `fieldset {
+  margin: 0;
+  padding: 0;
+}
+legend {
+  padding: 0;
+}`
+  },
+  // ── Interactive ──────────────────────────────────────────
+  {
+    name: "focus-visible",
+    category: "interactive",
+    css: `:focus-visible {
+  outline-width: 2px;
+  outline-style: solid;
+  outline-offset: 2px;
+  outline-color: currentColor;
+}`
+  },
+  {
+    name: "dialog-reset",
+    category: "interactive",
+    css: `dialog {
+  padding: 0;
+}
+dialog::backdrop {
+  background-color: oklch(0 0 0 / 0.5);
+}`
+  },
+  {
+    name: "summary-reset",
+    category: "interactive",
+    css: `summary {
+  display: list-item;
+  cursor: pointer;
+}`
+  },
+  // ── Modern ───────────────────────────────────────────────
+  {
+    name: "interpolate-size",
+    category: "modern",
+    css: `@supports (interpolate-size: allow-keywords) {
+  :root {
+    interpolate-size: allow-keywords;
+  }
+}`
+  },
+  {
+    name: "overflow-wrap",
+    category: "modern",
+    css: `body {
+  overflow-wrap: break-word;
+}`
+  },
+  {
+    name: "color-scheme",
+    category: "modern",
+    css: `html {
+  color-scheme: light dark;
+}
+html[data-appearance="dark"] {
+  color-scheme: dark;
+}
+html[data-appearance="light"] {
+  color-scheme: light;
+}`
+  }
+];
+function generatePreflight(config = DEFAULT_PREFLIGHT) {
+  const enabledModules = modules.filter((m) => config[m.category]);
+  if (enabledModules.length === 0) return "";
+  return enabledModules.map((m) => `/* preflight: ${m.name} */
+${m.css}`).join("\n\n");
+}
+
+// src/assembly.ts
+function resolveColorDemand(theme, usage) {
+  const shadowsToEmit = resolveTransitiveShadowDeps(theme.shadows, usage.usedShadows);
+  const effectiveStops = new Map(
+    [...usage.usedColorStops].map(([k, v]) => [k, new Set(v)])
+  );
+  const liveNames = new Set(usage.usedColorNames);
+  let demandGrew = true;
+  const addStops = (name, stops) => {
+    let set = effectiveStops.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      effectiveStops.set(name, set);
+      demandGrew = true;
+    }
+    for (const stop of stops) {
+      if (set.has(stop)) continue;
+      set.add(stop);
+      demandGrew = true;
+    }
+  };
+  const addName = (name) => {
+    if (liveNames.has(name)) return;
+    liveNames.add(name);
+    demandGrew = true;
+  };
+  const scanForColors = (text) => {
+    if (!text.includes("var(--color-")) return;
+    for (const m of text.matchAll(COLOR_VAR_REF_RE)) addName(m[1]);
+    for (const m of text.matchAll(COLOR_STOP_REF_RE)) {
+      if (m[2]) addStops(m[1], [Number(m[2])]);
+    }
+  };
+  for (const name of shadowsToEmit) scanForColors(theme.shadows[name] ?? "");
+  for (const body of usage.keyframes) scanForColors(body);
+  for (const registration of theme.registeredProperties) {
+    if (registration.initialValue) scanForColors(registration.initialValue);
+  }
+  while (demandGrew) {
+    demandGrew = false;
+    for (const [name, def] of Object.entries(theme.colors)) {
+      const stops = effectiveStops.get(name);
+      const liveByStop = stops !== void 0 && stops.size > 0;
+      const liveByName = liveNames.has(name);
+      if (!liveByStop && !liveByName) continue;
+      switch (def.type) {
+        case "alias":
+          if (liveByStop) addStops(def.source, [...stops]);
+          if (liveByName) addName(def.source);
+          break;
+        case "explicit":
+          scanForColors(def.value);
+          break;
+        case "pair":
+          scanForColors(def.light);
+          scanForColors(def.dark);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  const themeSuffixes = effectiveStops.get("theme");
+  if (theme.colors.theme && themeSuffixes) {
+    for (const [name, def] of Object.entries(theme.colors)) {
+      if (name === "theme" || def.type !== "generative" || !def.inline) continue;
+      addStops(name, themeSuffixes);
+    }
+  }
+  return { effectiveStops, liveNames, shadowsToEmit };
+}
+function generateTokenLayer(theme, usage, fontOutputCache, demand = resolveColorDemand(theme, usage)) {
+  const vars = [];
+  vars.push(`--spacing: ${theme.spacing.base};`);
+  const pushBounds = (prefix, config) => {
+    if (config?.min !== void 0) vars.push(`${prefix}-min: ${config.min};`);
+    if (config?.max !== void 0) vars.push(`${prefix}-max: ${config.max};`);
+  };
+  pushBounds("--fluid", theme.fluid);
+  pushBounds("--fluid-text", theme.textFluid);
+  pushBounds("--fluid-spacing", theme.spacingFluid);
+  for (const [name, range] of Object.entries(theme.fluidRanges)) {
+    pushBounds(`--fluid-${name}`, range);
+  }
+  const { effectiveStops, liveNames, shadowsToEmit } = demand;
+  const colorVars = generateAllColorVariables(
+    theme.colors,
+    theme.darkConfig,
+    effectiveStops,
+    liveNames
+  );
+  vars.push(...colorVars);
+  for (const [name, size] of Object.entries(theme.text).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!usage.usedTextSizes.has(name)) continue;
+    vars.push(`--text-${name}: ${size.fontSize};`);
+    vars.push(`--text-${name}-leading: ${size.lineHeight};`);
+  }
+  const configuredSlots = /* @__PURE__ */ new Set();
+  for (const fontConfig of theme.fonts) {
+    if (!usage.usedFonts.has(fontConfig.slot)) continue;
+    const output = getCachedFontOutput(fontConfig, fontOutputCache);
+    vars.push(...output.variables);
+    configuredSlots.add(fontConfig.slot);
+  }
+  for (const [slot, stack] of Object.entries(SYSTEM_STACKS).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!configuredSlots.has(slot) && usage.usedFonts.has(slot)) {
+      vars.push(`--font-${slot}: ${stack};`);
+    }
+  }
+  for (const [name, val] of Object.entries(theme.shadows).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!shadowsToEmit.has(name)) continue;
+    vars.push(`--shadow-${name}: ${val};`);
+  }
+  for (const [name, val] of Object.entries(theme.radii).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    vars.push(`--rounded-${name}: ${val};`);
+  }
+  for (const [name, def] of Object.entries(theme.animations).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!usage.usedAnimations.has(name)) continue;
+    vars.push(`--animate-${name}: ${def.shorthand};`);
+  }
+  return `:root {
+  ${vars.join("\n  ")}
+}`;
+}
+function resolveTransitiveShadowDeps(shadows, seeds) {
+  const out = /* @__PURE__ */ new Set();
+  const worklist = [];
+  for (const name of seeds) {
+    if (Object.hasOwn(shadows, name)) {
+      out.add(name);
+      worklist.push(name);
+    }
+  }
+  while (worklist.length > 0) {
+    const name = worklist.pop();
+    const value = shadows[name];
+    if (!value?.includes("var(--shadow-")) continue;
+    for (const m of value.matchAll(SHADOW_VAR_REF_RE)) {
+      const dep = m[1];
+      if (!out.has(dep) && Object.hasOwn(shadows, dep)) {
+        out.add(dep);
+        worklist.push(dep);
+      }
+    }
+  }
+  return out;
+}
+function cornerShapeValue(shape) {
+  return typeof shape === "string" ? shape : `superellipse(${shape.superellipse})`;
+}
+function generateCornerShapeBlock(theme) {
+  if (theme.roundedShape === null) return null;
+  const value = cornerShapeValue(theme.roundedShape);
+  const shapeRule = `:root {
+  corner-shape: ${value};
+}
+*, ::before, ::after {
+  corner-shape: inherit;
+}`;
+  if (theme.roundedShapeScale === 1) return shapeRule;
+  const scaleBlock = `@supports (corner-shape: ${value}) {
+  :root {
+    --ri-rounded-scale: ${theme.roundedShapeScale};
+  }
+}`;
+  return `${shapeRule}
+
+${scaleBlock}`;
+}
+function fontCacheKey(config) {
+  return JSON.stringify(config);
+}
+function getCachedFontOutput(config, cache) {
+  const key = fontCacheKey(config);
+  let cached = cache.get(key);
+  if (!cached) {
+    cached = generateFontCSS(config);
+    cache.set(key, cached);
+  }
+  return cached;
+}
+function renderRegisteredProperty(reg) {
+  const lines = [
+    `@property ${reg.name} {`,
+    `  syntax: ${reg.syntax};`,
+    `  inherits: ${reg.inherits};`
+  ];
+  if (reg.initialValue !== void 0) lines.push(`  initial-value: ${reg.initialValue};`);
+  lines.push("}");
+  return lines.join("\n");
+}
+var PROPERTY_NAME_RE = /@property\s+(--[A-Za-z0-9_-]+)/;
+function collectPropertyBlocks(registered, engineProperties) {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (block) => {
+    const name = PROPERTY_NAME_RE.exec(block)?.[1];
+    if (name) {
+      if (seen.has(name)) return;
+      seen.add(name);
+    }
+    blocks.push(block);
+  };
+  for (const reg of registered) push(renderRegisteredProperty(reg));
+  for (const block of engineProperties) push(block);
+  return blocks;
+}
+function assembleSections(compilation, theme, fontOutputCache) {
+  const baseSections = [];
+  const fontImports = [];
+  const fontFaceBlocks = [];
+  const assemblyWarnings = [];
+  const fontWarningsEmitted = /* @__PURE__ */ new Set();
+  if (theme.preflight.core !== false) {
+    compilation.usedFonts.add("sans");
+    compilation.usedFonts.add("mono");
+  }
+  for (const fontConfig of theme.fonts) {
+    if (!compilation.usedFonts.has(fontConfig.slot)) continue;
+    const output = getCachedFontOutput(fontConfig, fontOutputCache);
+    fontImports.push(...output.imports);
+    fontFaceBlocks.push(...output.fontFaces);
+    for (const w of output.warnings) {
+      if (!fontWarningsEmitted.has(w)) {
+        assemblyWarnings.push(w);
+        fontWarningsEmitted.add(w);
+      }
+    }
+  }
+  const importsSection = fontImports.length > 0 ? fontImports.join("\n") : null;
+  const propertyBlocks = collectPropertyBlocks(theme.registeredProperties, compilation.properties);
+  if (propertyBlocks.length > 0) {
+    baseSections.push(propertyBlocks.join("\n\n"));
+  }
+  if (fontFaceBlocks.length > 0) {
+    baseSections.push(fontFaceBlocks.join("\n\n"));
+  }
+  const demand = resolveColorDemand(theme, compilation);
+  const tokenLayer = generateTokenLayer(theme, compilation, fontOutputCache, demand);
+  if (tokenLayer) baseSections.push(tokenLayer);
+  for (const w of checkPaletteContrast(theme.colors, compilation.usedColorStops)) {
+    assemblyWarnings.push(w);
+  }
+  const themeOverrides = generateThemeOverrides(theme.colors, demand.effectiveStops.get("theme"));
+  if (themeOverrides.length > 0) {
+    baseSections.push(themeOverrides.join("\n\n"));
+  }
+  const cornerShape = generateCornerShapeBlock(theme);
+  if (cornerShape) baseSections.push(cornerShape);
+  if (compilation.keyframes.length > 0) {
+    baseSections.push(compilation.keyframes.join("\n\n"));
+  }
+  const preflight = generatePreflight(theme.preflight);
+  if (preflight) baseSections.push(preflight);
+  const utilityCSS = renderCSS({
+    ...compilation,
+    properties: [],
+    keyframes: []
+  });
+  const utilitiesSection = utilityCSS !== "" ? utilityCSS : null;
+  const parts = {
+    imports: importsSection,
+    base: baseSections,
+    utilities: utilitiesSection
+  };
+  const sections = theme.layer ? applyLayerWrapping(parts, theme.layer) : [
+    ...importsSection !== null ? [importsSection] : [],
+    ...baseSections,
+    ...utilitiesSection !== null ? [utilitiesSection] : []
+  ];
+  return { sections, warnings: assemblyWarnings };
+}
+function wrapInLayer(content, layerName) {
+  const indented = content.replace(/^(?=.)/gm, "  ");
+  return `@layer ${layerName} {
+${indented}
+}`;
+}
+function applyLayerWrapping(parts, layer) {
+  const sections = [];
+  if (parts.imports !== null) sections.push(parts.imports);
+  if (layer.wrapAll) {
+    sections.push(`@layer ${layer.wrapAll};`);
+    const joined = [...parts.base, ...parts.utilities !== null ? [parts.utilities] : []].join(
+      "\n\n"
+    );
+    if (joined) sections.push(wrapInLayer(joined, layer.wrapAll));
+    return sections;
+  }
+  if (layer.order && layer.order.length > 0) {
+    sections.push(`@layer ${layer.order.join(", ")};`);
+  }
+  if (parts.base.length > 0) {
+    const baseJoined = parts.base.join("\n\n");
+    if (layer.base) {
+      sections.push(wrapInLayer(baseJoined, layer.base));
+    } else {
+      sections.push(baseJoined);
+    }
+  }
+  if (parts.utilities !== null) {
+    if (layer.utilities) {
+      sections.push(wrapInLayer(parts.utilities, layer.utilities));
+    } else {
+      sections.push(parts.utilities);
+    }
+  }
+  return sections;
+}
+
 export {
-  COLOR_STOP_REF_RE,
-  SHADOW_VAR_REF_RE,
+  escapeSelector,
   isRIDebug,
   withTimeout,
+  stripCSSComments,
   isAtRuleBoundary,
   codepointCompare,
   APPLY_ALIASES,
@@ -10548,6 +12715,7 @@ export {
   matchCustomUtility,
   forEachApplyClassList,
   DIRECTIVE_TYPE_NAMES,
+  scanEntries,
   findClosingBrace,
   SAFE_FONT_FAMILY_RE,
   weightIsLoaded,
@@ -10583,10 +12751,8 @@ export {
   scanCSSForTokenUsage,
   createEmptyCompilationResult,
   createThemeSnapshot,
-  renderCSS,
   createCompiler,
   DIRECTIVE_NAMES_SET,
-  directiveAtRulePattern,
   isAtRuleNameChar,
   RI_IMPORT_SPECIFIERS,
   RI_IMPORT_SPECIFIER_ALTERNATION,
@@ -10594,16 +12760,20 @@ export {
   isSuppressible,
   parseFileDisables,
   resolveDirectives,
-  EXTRACTABLE_DIRECTIVE_NAMES,
   MAX_DIRECTIVE_INPUT_SIZE,
   extractDirectives,
+  expandApplyBodyGroups,
   expandVariantGroups,
-  expandApplyGroups,
+  expandGroupsInStylesheet,
   CLASS_HELPER_NAMES,
   VARIANT_HELPER_NAMES,
   extractClasses,
   extractClassesFromSource,
   extractClassCandidates,
+  getFontPreloadLinks,
+  stripRIDirectives,
+  inlineDirectiveImports,
   analyzeProjectCSSMemo,
-  analyzeProjectCSS
+  analyzeProjectCSS,
+  assembleSections
 };