@menapo/vicss 0.0.0-stage → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,1528 @@
+//#region src/runtime/css-properties.d.ts
+/** The token scales. */
+type ScaleName = "colors" | "spacing" | "sizes" | "radii" | "fonts" | "fontSizes" | "fontWeights" | "lineHeights" | "letterSpacings" | "shadows" | "textShadows" | "durations" | "easings" | "zIndices" | "opacities" | "blurs" | "aspectRatios" | "breakpoints" | "containers";
+/** CSS-wide keywords: every property takes them. */
+type WideKeyword = "inherit" | "initial" | "unset" | "revert" | "revert-layer";
+/** Scales whose properties take a percentage. */
+type PercentScale = "spacing" | "sizes" | "radii" | "fontSizes" | "lineHeights" | "opacities";
+/** What a bare number means on the properties of each scale (`none`: nothing). */
+interface ScaleNumberKinds {
+  colors: "none";
+  spacing: "spacing";
+  sizes: "sizes";
+  radii: "length";
+  fonts: "none";
+  fontSizes: "length";
+  fontWeights: "unitless";
+  lineHeights: "unitless";
+  letterSpacings: "length";
+  shadows: "none";
+  textShadows: "none";
+  durations: "time";
+  easings: "none";
+  zIndices: "unitless";
+  opacities: "unitless";
+  blurs: "length";
+  aspectRatios: "unitless";
+  breakpoints: "none";
+  containers: "none";
+}
+/** The keywords each scale takes besides its tokens. */
+interface ScaleKeywords {
+  colors: "transparent" | "currentColor" | "currentcolor" | "AccentColor" | "AccentColorText" | "ActiveText" | "ButtonBorder" | "ButtonFace" | "ButtonText" | "Canvas" | "CanvasText" | "Field" | "FieldText" | "GrayText" | "Highlight" | "HighlightText" | "LinkText" | "Mark" | "MarkText" | "SelectedItem" | "SelectedItemText" | "VisitedText";
+  spacing: "auto";
+  sizes: "auto" | "none" | "fit-content" | "min-content" | "max-content" | "stretch" | "-webkit-fill-available" | "content";
+  radii: never;
+  fonts: "serif" | "sans-serif" | "monospace" | "cursive" | "fantasy" | "system-ui" | "ui-serif" | "ui-sans-serif" | "ui-monospace" | "ui-rounded" | "math" | "emoji" | "fangsong";
+  fontSizes: "xx-small" | "x-small" | "small" | "medium" | "large" | "x-large" | "xx-large" | "xxx-large" | "smaller" | "larger" | "math";
+  fontWeights: "normal" | "bold" | "bolder" | "lighter";
+  lineHeights: "normal";
+  letterSpacings: "normal";
+  shadows: "none";
+  textShadows: "none";
+  durations: "auto";
+  easings: "linear" | "ease" | "ease-in" | "ease-out" | "ease-in-out" | "step-start" | "step-end";
+  zIndices: "auto";
+  opacities: never;
+  blurs: never;
+  aspectRatios: "auto";
+  breakpoints: never;
+  containers: never;
+}
+/** Every CSS property a style object takes, by its camelCase name. */
+interface CssProperties {
+  MozOsxFontSmoothing?: ConditionalValue<Unscaled<"none">>;
+  WebkitBoxOrient?: ConditionalValue<Unscaled<"none">>;
+  WebkitFontSmoothing?: ConditionalValue<Unscaled<"none">>;
+  WebkitLineClamp?: ConditionalValue<Unscaled<"unitless">>;
+  WebkitTapHighlightColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  WebkitTextFillColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  accentColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  alignContent?: ConditionalValue<Unscaled<"none">>;
+  alignItems?: ConditionalValue<Unscaled<"none">>;
+  alignSelf?: ConditionalValue<Unscaled<"none">>;
+  anchorName?: ConditionalValue<Unscaled<"none">>;
+  anchorScope?: ConditionalValue<Unscaled<"none">>;
+  animation?: ConditionalValue<Unscaled<"none">>;
+  animationComposition?: ConditionalValue<Unscaled<"none">>;
+  animationDelay?: ConditionalValue<ScaleValue<"durations", "time">>;
+  animationDirection?: ConditionalValue<Unscaled<"none">>;
+  animationDuration?: ConditionalValue<ScaleValue<"durations", "time">>;
+  animationFillMode?: ConditionalValue<Unscaled<"none">>;
+  animationIterationCount?: ConditionalValue<Unscaled<"unitless">>;
+  animationName?: ConditionalValue<Unscaled<"none">>;
+  animationPlayState?: ConditionalValue<Unscaled<"none">>;
+  animationRange?: ConditionalValue<Unscaled<"length">>;
+  animationRangeEnd?: ConditionalValue<Unscaled<"length">>;
+  animationRangeStart?: ConditionalValue<Unscaled<"length">>;
+  animationTimeline?: ConditionalValue<Unscaled<"none">>;
+  animationTimingFunction?: ConditionalValue<ScaleValue<"easings", "none">>;
+  appearance?: ConditionalValue<Unscaled<"none">>;
+  aspectRatio?: ConditionalValue<ScaleValue<"aspectRatios", "unitless">>;
+  backdropFilter?: ConditionalValue<Unscaled<"none">>;
+  backfaceVisibility?: ConditionalValue<Unscaled<"none">>;
+  background?: ConditionalValue<ScaleValue<"colors", "none">>;
+  backgroundAttachment?: ConditionalValue<Unscaled<"none">>;
+  backgroundBlendMode?: ConditionalValue<Unscaled<"none">>;
+  backgroundClip?: ConditionalValue<Unscaled<"none">>;
+  backgroundColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  backgroundImage?: ConditionalValue<Unscaled<"none">>;
+  backgroundOrigin?: ConditionalValue<Unscaled<"none">>;
+  backgroundPosition?: ConditionalValue<Unscaled<"length">>;
+  backgroundPositionX?: ConditionalValue<Unscaled<"length">>;
+  backgroundPositionY?: ConditionalValue<Unscaled<"length">>;
+  backgroundRepeat?: ConditionalValue<Unscaled<"none">>;
+  backgroundSize?: ConditionalValue<Unscaled<"length">>;
+  blockSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  border?: ConditionalValue<Unscaled<"none">>;
+  borderBlock?: ConditionalValue<Unscaled<"none">>;
+  borderBlockColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderBlockEnd?: ConditionalValue<Unscaled<"none">>;
+  borderBlockEndColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderBlockEndStyle?: ConditionalValue<Unscaled<"none">>;
+  borderBlockEndWidth?: ConditionalValue<Unscaled<"length">>;
+  borderBlockStart?: ConditionalValue<Unscaled<"none">>;
+  borderBlockStartColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderBlockStartStyle?: ConditionalValue<Unscaled<"none">>;
+  borderBlockStartWidth?: ConditionalValue<Unscaled<"length">>;
+  borderBlockStyle?: ConditionalValue<Unscaled<"none">>;
+  borderBlockWidth?: ConditionalValue<Unscaled<"length">>;
+  borderBottom?: ConditionalValue<Unscaled<"none">>;
+  borderBottomColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderBottomLeftRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderBottomRightRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderBottomStyle?: ConditionalValue<Unscaled<"none">>;
+  borderBottomWidth?: ConditionalValue<Unscaled<"length">>;
+  borderCollapse?: ConditionalValue<Unscaled<"none">>;
+  borderColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderEndEndRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderEndStartRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderImage?: ConditionalValue<Unscaled<"none">>;
+  borderImageOutset?: ConditionalValue<Unscaled<"unitless">>;
+  borderImageRepeat?: ConditionalValue<Unscaled<"none">>;
+  borderImageSlice?: ConditionalValue<Unscaled<"unitless">>;
+  borderImageSource?: ConditionalValue<Unscaled<"none">>;
+  borderImageWidth?: ConditionalValue<Unscaled<"unitless">>;
+  borderInline?: ConditionalValue<Unscaled<"none">>;
+  borderInlineColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderInlineEnd?: ConditionalValue<Unscaled<"none">>;
+  borderInlineEndColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderInlineEndStyle?: ConditionalValue<Unscaled<"none">>;
+  borderInlineEndWidth?: ConditionalValue<Unscaled<"length">>;
+  borderInlineStart?: ConditionalValue<Unscaled<"none">>;
+  borderInlineStartColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderInlineStartStyle?: ConditionalValue<Unscaled<"none">>;
+  borderInlineStartWidth?: ConditionalValue<Unscaled<"length">>;
+  borderInlineStyle?: ConditionalValue<Unscaled<"none">>;
+  borderInlineWidth?: ConditionalValue<Unscaled<"length">>;
+  borderLeft?: ConditionalValue<Unscaled<"none">>;
+  borderLeftColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderLeftStyle?: ConditionalValue<Unscaled<"none">>;
+  borderLeftWidth?: ConditionalValue<Unscaled<"length">>;
+  borderRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderRight?: ConditionalValue<Unscaled<"none">>;
+  borderRightColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderRightStyle?: ConditionalValue<Unscaled<"none">>;
+  borderRightWidth?: ConditionalValue<Unscaled<"length">>;
+  borderSpacing?: ConditionalValue<Unscaled<"length">>;
+  borderStartEndRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderStartStartRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderStyle?: ConditionalValue<Unscaled<"none">>;
+  borderTop?: ConditionalValue<Unscaled<"none">>;
+  borderTopColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  borderTopLeftRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderTopRightRadius?: ConditionalValue<ScaleValue<"radii", "length">>;
+  borderTopStyle?: ConditionalValue<Unscaled<"none">>;
+  borderTopWidth?: ConditionalValue<Unscaled<"length">>;
+  borderWidth?: ConditionalValue<Unscaled<"length">>;
+  bottom?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  boxDecorationBreak?: ConditionalValue<Unscaled<"none">>;
+  boxShadow?: ConditionalValue<ScaleValue<"shadows", "none">>;
+  boxSizing?: ConditionalValue<Unscaled<"none">>;
+  breakAfter?: ConditionalValue<Unscaled<"none">>;
+  breakBefore?: ConditionalValue<Unscaled<"none">>;
+  breakInside?: ConditionalValue<Unscaled<"none">>;
+  captionSide?: ConditionalValue<Unscaled<"none">>;
+  caretColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  clear?: ConditionalValue<Unscaled<"none">>;
+  clip?: ConditionalValue<Unscaled<"none">>;
+  clipPath?: ConditionalValue<Unscaled<"none">>;
+  clipRule?: ConditionalValue<Unscaled<"none">>;
+  color?: ConditionalValue<ScaleValue<"colors", "none">>;
+  colorInterpolation?: ConditionalValue<Unscaled<"none">>;
+  colorInterpolationFilters?: ConditionalValue<Unscaled<"none">>;
+  colorScheme?: ConditionalValue<Unscaled<"none">>;
+  columnCount?: ConditionalValue<Unscaled<"unitless">>;
+  columnFill?: ConditionalValue<Unscaled<"none">>;
+  columnGap?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  columnRule?: ConditionalValue<Unscaled<"none">>;
+  columnRuleColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  columnRuleStyle?: ConditionalValue<Unscaled<"none">>;
+  columnRuleWidth?: ConditionalValue<Unscaled<"length">>;
+  columnSpan?: ConditionalValue<Unscaled<"none">>;
+  columnWidth?: ConditionalValue<Unscaled<"length">>;
+  columns?: ConditionalValue<Unscaled<"unitless">>;
+  contain?: ConditionalValue<Unscaled<"none">>;
+  containIntrinsicSize?: ConditionalValue<Unscaled<"length">>;
+  container?: ConditionalValue<Unscaled<"none">>;
+  containerName?: ConditionalValue<Unscaled<"none">>;
+  containerType?: ConditionalValue<Unscaled<"none">>;
+  content?: ConditionalValue<Unscaled<"none">>;
+  contentVisibility?: ConditionalValue<Unscaled<"none">>;
+  counterIncrement?: ConditionalValue<Unscaled<"none">>;
+  counterReset?: ConditionalValue<Unscaled<"none">>;
+  counterSet?: ConditionalValue<Unscaled<"none">>;
+  cursor?: ConditionalValue<Unscaled<"none">>;
+  direction?: ConditionalValue<Unscaled<"none">>;
+  display?: ConditionalValue<Unscaled<"none">>;
+  dominantBaseline?: ConditionalValue<Unscaled<"none">>;
+  emptyCells?: ConditionalValue<Unscaled<"none">>;
+  fieldSizing?: ConditionalValue<Unscaled<"none">>;
+  fill?: ConditionalValue<ScaleValue<"colors", "none">>;
+  fillOpacity?: ConditionalValue<Unscaled<"unitless">>;
+  fillRule?: ConditionalValue<Unscaled<"none">>;
+  filter?: ConditionalValue<Unscaled<"none">>;
+  flex?: ConditionalValue<Unscaled<"unitless">>;
+  flexBasis?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  flexDirection?: ConditionalValue<Unscaled<"none">>;
+  flexFlow?: ConditionalValue<Unscaled<"none">>;
+  flexGrow?: ConditionalValue<Unscaled<"unitless">>;
+  flexShrink?: ConditionalValue<Unscaled<"unitless">>;
+  flexWrap?: ConditionalValue<Unscaled<"none">>;
+  float?: ConditionalValue<Unscaled<"none">>;
+  floodColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  floodOpacity?: ConditionalValue<Unscaled<"unitless">>;
+  fontFamily?: ConditionalValue<ScaleValue<"fonts", "none">>;
+  fontFeatureSettings?: ConditionalValue<Unscaled<"none">>;
+  fontKerning?: ConditionalValue<Unscaled<"none">>;
+  fontOpticalSizing?: ConditionalValue<Unscaled<"none">>;
+  fontPalette?: ConditionalValue<Unscaled<"none">>;
+  fontSize?: ConditionalValue<ScaleValue<"fontSizes", "length">>;
+  fontSizeAdjust?: ConditionalValue<Unscaled<"unitless">>;
+  fontStretch?: ConditionalValue<Unscaled<"none">>;
+  fontStyle?: ConditionalValue<Unscaled<"none">>;
+  fontSynthesis?: ConditionalValue<Unscaled<"none">>;
+  fontVariant?: ConditionalValue<Unscaled<"none">>;
+  fontVariantAlternates?: ConditionalValue<Unscaled<"none">>;
+  fontVariantCaps?: ConditionalValue<Unscaled<"none">>;
+  fontVariantEastAsian?: ConditionalValue<Unscaled<"none">>;
+  fontVariantLigatures?: ConditionalValue<Unscaled<"none">>;
+  fontVariantNumeric?: ConditionalValue<Unscaled<"none">>;
+  fontVariantPosition?: ConditionalValue<Unscaled<"none">>;
+  fontVariationSettings?: ConditionalValue<Unscaled<"none">>;
+  fontWeight?: ConditionalValue<ScaleValue<"fontWeights", "unitless">>;
+  forcedColorAdjust?: ConditionalValue<Unscaled<"none">>;
+  gap?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  gridArea?: ConditionalValue<Unscaled<"unitless">>;
+  gridAutoColumns?: ConditionalValue<Unscaled<"length">>;
+  gridAutoFlow?: ConditionalValue<Unscaled<"none">>;
+  gridAutoRows?: ConditionalValue<Unscaled<"length">>;
+  gridColumn?: ConditionalValue<Unscaled<"unitless">>;
+  gridColumnEnd?: ConditionalValue<Unscaled<"unitless">>;
+  gridColumnStart?: ConditionalValue<Unscaled<"unitless">>;
+  gridRow?: ConditionalValue<Unscaled<"unitless">>;
+  gridRowEnd?: ConditionalValue<Unscaled<"unitless">>;
+  gridRowStart?: ConditionalValue<Unscaled<"unitless">>;
+  gridTemplate?: ConditionalValue<Unscaled<"none">>;
+  gridTemplateAreas?: ConditionalValue<Unscaled<"none">>;
+  gridTemplateColumns?: ConditionalValue<Unscaled<"length">>;
+  gridTemplateRows?: ConditionalValue<Unscaled<"length">>;
+  height?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  hyphenateCharacter?: ConditionalValue<Unscaled<"none">>;
+  hyphens?: ConditionalValue<Unscaled<"none">>;
+  imageOrientation?: ConditionalValue<Unscaled<"none">>;
+  imageRendering?: ConditionalValue<Unscaled<"none">>;
+  inlineSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  inset?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetBlock?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetBlockEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetBlockStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetInline?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetInlineEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  insetInlineStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  interpolateSize?: ConditionalValue<Unscaled<"none">>;
+  isolation?: ConditionalValue<Unscaled<"none">>;
+  justifyContent?: ConditionalValue<Unscaled<"none">>;
+  justifyItems?: ConditionalValue<Unscaled<"none">>;
+  justifySelf?: ConditionalValue<Unscaled<"none">>;
+  left?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  letterSpacing?: ConditionalValue<ScaleValue<"letterSpacings", "length">>;
+  lightingColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  lineBreak?: ConditionalValue<Unscaled<"none">>;
+  lineHeight?: ConditionalValue<ScaleValue<"lineHeights", "unitless">>;
+  listStyle?: ConditionalValue<Unscaled<"none">>;
+  listStyleImage?: ConditionalValue<Unscaled<"none">>;
+  listStylePosition?: ConditionalValue<Unscaled<"none">>;
+  listStyleType?: ConditionalValue<Unscaled<"none">>;
+  margin?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginBlock?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginBlockEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginBlockStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginBottom?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginInline?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginInlineEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginInlineStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginLeft?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginRight?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  marginTop?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  markerEnd?: ConditionalValue<Unscaled<"none">>;
+  markerMid?: ConditionalValue<Unscaled<"none">>;
+  markerStart?: ConditionalValue<Unscaled<"none">>;
+  mask?: ConditionalValue<Unscaled<"none">>;
+  maskClip?: ConditionalValue<Unscaled<"none">>;
+  maskComposite?: ConditionalValue<Unscaled<"none">>;
+  maskImage?: ConditionalValue<Unscaled<"none">>;
+  maskMode?: ConditionalValue<Unscaled<"none">>;
+  maskOrigin?: ConditionalValue<Unscaled<"none">>;
+  maskPosition?: ConditionalValue<Unscaled<"length">>;
+  maskRepeat?: ConditionalValue<Unscaled<"none">>;
+  maskSize?: ConditionalValue<Unscaled<"length">>;
+  maskType?: ConditionalValue<Unscaled<"none">>;
+  maxBlockSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  maxHeight?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  maxInlineSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  maxWidth?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  minBlockSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  minHeight?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  minInlineSize?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  minWidth?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  mixBlendMode?: ConditionalValue<Unscaled<"none">>;
+  objectFit?: ConditionalValue<Unscaled<"none">>;
+  objectPosition?: ConditionalValue<Unscaled<"length">>;
+  opacity?: ConditionalValue<ScaleValue<"opacities", "unitless">>;
+  order?: ConditionalValue<Unscaled<"unitless">>;
+  orphans?: ConditionalValue<Unscaled<"unitless">>;
+  outline?: ConditionalValue<Unscaled<"none">>;
+  outlineColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  outlineOffset?: ConditionalValue<Unscaled<"length">>;
+  outlineStyle?: ConditionalValue<Unscaled<"none">>;
+  outlineWidth?: ConditionalValue<Unscaled<"length">>;
+  overflow?: ConditionalValue<Unscaled<"none">>;
+  overflowAnchor?: ConditionalValue<Unscaled<"none">>;
+  overflowBlock?: ConditionalValue<Unscaled<"none">>;
+  overflowClipMargin?: ConditionalValue<Unscaled<"length">>;
+  overflowInline?: ConditionalValue<Unscaled<"none">>;
+  overflowWrap?: ConditionalValue<Unscaled<"none">>;
+  overflowX?: ConditionalValue<Unscaled<"none">>;
+  overflowY?: ConditionalValue<Unscaled<"none">>;
+  overscrollBehavior?: ConditionalValue<Unscaled<"none">>;
+  overscrollBehaviorBlock?: ConditionalValue<Unscaled<"none">>;
+  overscrollBehaviorInline?: ConditionalValue<Unscaled<"none">>;
+  overscrollBehaviorX?: ConditionalValue<Unscaled<"none">>;
+  overscrollBehaviorY?: ConditionalValue<Unscaled<"none">>;
+  padding?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingBlock?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingBlockEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingBlockStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingBottom?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingInline?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingInlineEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingInlineStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingLeft?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingRight?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paddingTop?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  paintOrder?: ConditionalValue<Unscaled<"none">>;
+  perspective?: ConditionalValue<Unscaled<"length">>;
+  perspectiveOrigin?: ConditionalValue<Unscaled<"length">>;
+  placeContent?: ConditionalValue<Unscaled<"none">>;
+  placeItems?: ConditionalValue<Unscaled<"none">>;
+  placeSelf?: ConditionalValue<Unscaled<"none">>;
+  pointerEvents?: ConditionalValue<Unscaled<"none">>;
+  position?: ConditionalValue<Unscaled<"none">>;
+  positionAnchor?: ConditionalValue<Unscaled<"none">>;
+  positionArea?: ConditionalValue<Unscaled<"none">>;
+  positionTry?: ConditionalValue<Unscaled<"none">>;
+  positionTryFallbacks?: ConditionalValue<Unscaled<"none">>;
+  positionTryOrder?: ConditionalValue<Unscaled<"none">>;
+  positionVisibility?: ConditionalValue<Unscaled<"none">>;
+  printColorAdjust?: ConditionalValue<Unscaled<"none">>;
+  quotes?: ConditionalValue<Unscaled<"none">>;
+  resize?: ConditionalValue<Unscaled<"none">>;
+  right?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  rotate?: ConditionalValue<Unscaled<"angle">>;
+  rowGap?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  rubyPosition?: ConditionalValue<Unscaled<"none">>;
+  scale?: ConditionalValue<Unscaled<"unitless">>;
+  scrollBehavior?: ConditionalValue<Unscaled<"none">>;
+  scrollMargin?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginBlock?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginBlockEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginBlockStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginBottom?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginInline?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginInlineEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginInlineStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginLeft?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginRight?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollMarginTop?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPadding?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingBlock?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingBlockEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingBlockStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingBottom?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingInline?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingInlineEnd?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingInlineStart?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingLeft?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingRight?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollPaddingTop?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  scrollSnapAlign?: ConditionalValue<Unscaled<"none">>;
+  scrollSnapStop?: ConditionalValue<Unscaled<"none">>;
+  scrollSnapType?: ConditionalValue<Unscaled<"none">>;
+  scrollTimeline?: ConditionalValue<Unscaled<"none">>;
+  scrollTimelineAxis?: ConditionalValue<Unscaled<"none">>;
+  scrollTimelineName?: ConditionalValue<Unscaled<"none">>;
+  scrollbarColor?: ConditionalValue<Unscaled<"none">>;
+  scrollbarGutter?: ConditionalValue<Unscaled<"none">>;
+  scrollbarWidth?: ConditionalValue<Unscaled<"none">>;
+  shapeImageThreshold?: ConditionalValue<Unscaled<"unitless">>;
+  shapeMargin?: ConditionalValue<Unscaled<"length">>;
+  shapeOutside?: ConditionalValue<Unscaled<"none">>;
+  shapeRendering?: ConditionalValue<Unscaled<"none">>;
+  stopColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  stopOpacity?: ConditionalValue<Unscaled<"unitless">>;
+  stroke?: ConditionalValue<ScaleValue<"colors", "none">>;
+  strokeDasharray?: ConditionalValue<Unscaled<"unitless">>;
+  strokeDashoffset?: ConditionalValue<Unscaled<"unitless">>;
+  strokeLinecap?: ConditionalValue<Unscaled<"none">>;
+  strokeLinejoin?: ConditionalValue<Unscaled<"none">>;
+  strokeMiterlimit?: ConditionalValue<Unscaled<"unitless">>;
+  strokeOpacity?: ConditionalValue<Unscaled<"unitless">>;
+  strokeWidth?: ConditionalValue<Unscaled<"unitless">>;
+  tabSize?: ConditionalValue<Unscaled<"unitless">>;
+  tableLayout?: ConditionalValue<Unscaled<"none">>;
+  textAlign?: ConditionalValue<Unscaled<"none">>;
+  textAlignLast?: ConditionalValue<Unscaled<"none">>;
+  textAnchor?: ConditionalValue<Unscaled<"none">>;
+  textBox?: ConditionalValue<Unscaled<"none">>;
+  textBoxEdge?: ConditionalValue<Unscaled<"none">>;
+  textBoxTrim?: ConditionalValue<Unscaled<"none">>;
+  textCombineUpright?: ConditionalValue<Unscaled<"none">>;
+  textDecoration?: ConditionalValue<Unscaled<"none">>;
+  textDecorationColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  textDecorationLine?: ConditionalValue<Unscaled<"none">>;
+  textDecorationSkipInk?: ConditionalValue<Unscaled<"none">>;
+  textDecorationStyle?: ConditionalValue<Unscaled<"none">>;
+  textDecorationThickness?: ConditionalValue<Unscaled<"length">>;
+  textEmphasis?: ConditionalValue<Unscaled<"none">>;
+  textEmphasisColor?: ConditionalValue<ScaleValue<"colors", "none">>;
+  textEmphasisPosition?: ConditionalValue<Unscaled<"none">>;
+  textEmphasisStyle?: ConditionalValue<Unscaled<"none">>;
+  textIndent?: ConditionalValue<Unscaled<"length">>;
+  textJustify?: ConditionalValue<Unscaled<"none">>;
+  textOrientation?: ConditionalValue<Unscaled<"none">>;
+  textOverflow?: ConditionalValue<Unscaled<"none">>;
+  textRendering?: ConditionalValue<Unscaled<"none">>;
+  textShadow?: ConditionalValue<ScaleValue<"textShadows", "none">>;
+  textSizeAdjust?: ConditionalValue<Unscaled<"none">>;
+  textTransform?: ConditionalValue<Unscaled<"none">>;
+  textUnderlineOffset?: ConditionalValue<Unscaled<"length">>;
+  textUnderlinePosition?: ConditionalValue<Unscaled<"none">>;
+  textWrap?: ConditionalValue<Unscaled<"none">>;
+  timelineScope?: ConditionalValue<Unscaled<"none">>;
+  top?: ConditionalValue<ScaleValue<"spacing", "spacing">>;
+  touchAction?: ConditionalValue<Unscaled<"none">>;
+  transform?: ConditionalValue<Unscaled<"none">>;
+  transformBox?: ConditionalValue<Unscaled<"none">>;
+  transformOrigin?: ConditionalValue<Unscaled<"length">>;
+  transformStyle?: ConditionalValue<Unscaled<"none">>;
+  transition?: ConditionalValue<Unscaled<"none">>;
+  transitionBehavior?: ConditionalValue<Unscaled<"none">>;
+  transitionDelay?: ConditionalValue<ScaleValue<"durations", "time">>;
+  transitionDuration?: ConditionalValue<ScaleValue<"durations", "time">>;
+  transitionProperty?: ConditionalValue<Unscaled<"none">>;
+  transitionTimingFunction?: ConditionalValue<ScaleValue<"easings", "none">>;
+  translate?: ConditionalValue<Unscaled<"length">>;
+  unicodeBidi?: ConditionalValue<Unscaled<"none">>;
+  userSelect?: ConditionalValue<Unscaled<"none">>;
+  vectorEffect?: ConditionalValue<Unscaled<"none">>;
+  verticalAlign?: ConditionalValue<Unscaled<"length">>;
+  viewTimeline?: ConditionalValue<Unscaled<"none">>;
+  viewTimelineAxis?: ConditionalValue<Unscaled<"none">>;
+  viewTimelineInset?: ConditionalValue<Unscaled<"length">>;
+  viewTimelineName?: ConditionalValue<Unscaled<"none">>;
+  viewTransitionClass?: ConditionalValue<Unscaled<"none">>;
+  viewTransitionName?: ConditionalValue<Unscaled<"none">>;
+  visibility?: ConditionalValue<Unscaled<"none">>;
+  whiteSpace?: ConditionalValue<Unscaled<"none">>;
+  widows?: ConditionalValue<Unscaled<"unitless">>;
+  width?: ConditionalValue<ScaleValue<"sizes", "sizes">>;
+  willChange?: ConditionalValue<Unscaled<"none">>;
+  wordBreak?: ConditionalValue<Unscaled<"none">>;
+  wordSpacing?: ConditionalValue<Unscaled<"length">>;
+  writingMode?: ConditionalValue<Unscaled<"none">>;
+  zIndex?: ConditionalValue<ScaleValue<"zIndices", "unitless">>;
+  zoom?: ConditionalValue<Unscaled<"unitless">>;
+}
+//#endregion
+//#region src/runtime/types.d.ts
+/**
+ * The project's design system as types, declared by the generated
+ * `vicss.d.ts` (the plugin writes it whenever the config loads; `vicss types`
+ * writes it in CI):
+ *
+ * ```ts
+ * declare module "@menapo/vicss" {
+ *   interface Register {
+ *     tokens: { colors: "accent" | "blue.600"; spacing: number; … };
+ *     conditions: "_hover" | "_md" | …;
+ *     textStyles: "heading";
+ *     utilities: { size: "sizes"; truncate: boolean };
+ *     sets: { size: "height" | "width"; textStyle: "fontSize" | …; … };
+ *     strict: { colors: "css"; … };
+ *     responsive: "_md" | "_lg" | "_containerMd" | …;
+ *     markerStates: "hover" | "checked" | "current" | …;
+ *     palettes: "blue" | "gray" | "red" | …;
+ *     framework: "vue";
+ *   }
+ * }
+ * ```
+ */
+interface Register {}
+/** Token paths per scale, a number where it names a token, `number` on a stepped spacing scale. */
+type Tokens = Register extends {
+  tokens: infer T;
+} ? T : OpenTokens;
+/** Before generation: any string, and numbers for spacing. */
+type OpenTokens = { [S in ScaleName]: S extends "spacing" ? string | number : string; };
+/** The token paths of one scale: `Token<"colors">` is `"accent" | "blue.600" | …`. */
+type Token<S extends ScaleName> = S extends keyof Tokens ? Tokens[S] : string;
+/**
+ * The palettes `colorPalette` names (`palettes` in the config), as a
+ * function style's parameter takes one: `(tone: Palette) => ({ colorPalette:
+ * tone })`. Any string before generation; none when the design system has
+ * no palettes. Private tokens are left out of `Tokens`; palette keys
+ * (`palette.600`) are colour tokens like any other.
+ */
+type Palette = Register extends {
+  palettes: infer P extends string;
+} ? P : Register extends {
+  tokens: unknown;
+} ? never : string;
+/** Condition keys: `"_hover" | "_md" | …`. */
+type Conditions = Register extends {
+  conditions: infer C extends string;
+} ? C : `_${string}`;
+/** Text style names (`textStyles` in the config). */
+type TextStyles = Register extends {
+  textStyles: infer T extends string;
+} ? T : string;
+/**
+ * Strictness per scale (D8). Only `"tokens"` closes a scale to values
+ * outside it in the types; under the others any string type-checks, and
+ * the build tells a valid CSS value from a mistyped token.
+ */
+type Strict = Register extends {
+  strict: infer S;
+} ? S : OpenStrict;
+type OpenStrict = { [S in ScaleName]: "off"; };
+type Strictness<S extends ScaleName> = S extends keyof Strict ? Strict[S] : "off";
+/**
+ * Utilities by name, as registered: a scale name for a utility that takes
+ * the scale's values, `boolean` for a flag, `unknown` for anything else.
+ */
+type RegisteredUtilities = Register extends {
+  utilities: infer U;
+} ? U : OpenUtilities;
+interface OpenUtilities {
+  size: "sizes";
+  truncate: boolean;
+  srOnly: boolean;
+}
+/** The value each utility takes: its scale's values, or `boolean` for a flag. */
+type Utilities = { [K in keyof RegisteredUtilities]: UtilityValue<RegisteredUtilities[K]>; };
+type UtilityValue<U> = U extends ScaleName ? ScaleValue<U> : U extends boolean ? boolean : string | number | boolean;
+/**
+ * The style keys each utility and `textStyle` set: a `Style` records those
+ * rather than the utility's own name, so `Style<"margin">` takes
+ * `css({ m: 4 })`. `string` for a utility whose output the generator could
+ * not tell.
+ */
+type Sets = Register extends {
+  sets: infer X;
+} ? X : OpenSets;
+/** Before generation: the built-in utilities (core/system.ts), which every project has. */
+interface OpenSets {
+  size: "height" | "width";
+  srOnly: "borderWidth" | "clip" | "height" | "margin" | "overflow" | "padding" | "position" | "whiteSpace" | "width";
+  truncate: "overflow" | "textOverflow" | "whiteSpace";
+}
+/**
+ * What a `Style` records for style keys `K`: CSS properties, with utilities
+ * replaced by what they set. Most styles use no utility, which the first
+ * test answers without distributing over `K` (a third of a css() call's
+ * check time otherwise, tests/types/budget.test.ts).
+ */
+type Recorded<K> = [K & keyof Sets] extends [never] ? K : Exclude<K, keyof Sets> | Sets[K & keyof Sets];
+type Vars$1 = Record<string, string>;
+/**
+ * What `sx()` returns per framework (PLAN §5.12): the class attribute each
+ * one takes, and its `style` as an object or an `a:b;c:d` string.
+ */
+interface SxShapes {
+  react: {
+    className: string;
+    style?: Vars$1;
+  };
+  preact: {
+    className: string;
+    style?: Vars$1;
+  };
+  solid: {
+    class: string;
+    style?: Vars$1;
+  };
+  vue: {
+    class: string;
+    style?: Vars$1;
+  };
+  svelte: {
+    class: string;
+    style?: string;
+  };
+  astro: {
+    class: string;
+    style?: string;
+  };
+  vanilla: {
+    class: string;
+    style?: string;
+  };
+}
+/**
+ * The project's framework, which `vicss.d.ts` registers as the plugin
+ * detected it (the `framework` option, else the root `package.json`'s
+ * dependencies, §5.12); React when none is registered, `sx` being React's
+ * shape itself.
+ */
+type RegisteredFramework = Register extends {
+  framework: infer Framework extends keyof SxShapes;
+} ? Framework : "react";
+/** The attributes `sx()` returns: in this project, or in framework `F`. */
+type SxAttributes<F extends keyof SxShapes = RegisteredFramework> = SxShapes[F];
+/**
+ * What a bare number means on a property (core/properties.ts `NumberKind`):
+ * a spacing step, a plain number, a length, time or angle in its default
+ * unit, or nothing.
+ */
+type NumberKind = "spacing" | "sizes" | "unitless" | "length" | "time" | "angle" | "none";
+/** Any string, without swallowing the literals beside it in completions. */
+type AnyString = string & Record<never, never>;
+/** A string holding a token reference: `"{colors.accent}"`, `"color-mix(in oklab, {colors.accent} 50%, white)"`. */
+type TokenReference = `${string}{${string}}${string}` & Record<never, never>;
+type Percentage = `${number}%` & Record<never, never>;
+/** A number written as a string, which the build reads as the number: `"600"`, `"1.5"`, `"-4"`. */
+type NumericString = `${number}` & Record<never, never>;
+/** Zero as a length written as a string, as most write it; the build reads it as `0`. */
+type ZeroLength = "0" | "0px" | "0rem" | "0em";
+/** Zero as a time written as a string. */
+type ZeroTime = "0" | "0s" | "0ms";
+/**
+ * The value of a property on scale `S` whose numbers mean `N` (spec S9, S10):
+ * the scale's tokens, the numbers the build gives a meaning, the scale's
+ * keywords and token references, listed for completion; and any string,
+ * which the build checks, unless the scale takes tokens only.
+ */
+type ScaleValue<S extends ScaleName, N extends NumberKind = ScaleNumberKinds[S]> = Token<S> | ScaleNumber<S, N> | ScaleKeywords[S] | WideKeyword | (S extends PercentScale ? Percentage : never) | TokenReference | (Strictness<S> extends "tokens" ? never : AnyString);
+/**
+ * Numbers on a scale, and the strings the build reads as those numbers:
+ * spacing steps (or spacing tokens named by numbers), any number where it is
+ * plain, and only zero where any other number would be a length outside a
+ * strict scale. Tokens named by numbers are in `Token<S>`.
+ */
+type ScaleNumber<S extends ScaleName, N extends NumberKind> = N extends "spacing" | "sizes" ? Extract<Token<"spacing">, number> | 0 | ZeroLength | (number extends Extract<Token<"spacing">, number> ? NumericString : never) : N extends "unitless" ? number | NumericString : N extends "angle" ? number : N extends "length" ? Strictness<S> extends "tokens" ? 0 | ZeroLength : number : N extends "time" ? Strictness<S> extends "tokens" ? 0 | ZeroTime : number : never;
+/** The value of a property without a scale: any CSS string, and numbers where they mean something. */
+type Unscaled<N extends NumberKind> = string | (N extends "none" ? never : number);
+/**
+ * A condition key made by a marker: `[row.hover]` (PLAN §4.5). The compiler
+ * evaluates it to `__vx:m:<family>:<id>:<state>` (core/conditions.ts).
+ */
+type MarkerKey = `__vx:m:${string}`;
+/** `{ base: 4, _md: 6, _hover: { _md: 8 }, [row.hover]: 2 }`: a value per condition. */
+interface ConditionalObject<V> extends ConditionMap<V> {
+  base?: V;
+  readonly [marker: MarkerKey]: ConditionalValue<V> | undefined;
+}
+type ConditionMap<V> = { [C in Conditions]?: ConditionalValue<V>; };
+/** A value, or a value per condition. */
+type ConditionalValue<V> = V | ConditionalObject<V>;
+/** Utility names registered for the project; none before generation. */
+type UtilityNames = Register extends {
+  utilities: infer U;
+} ? keyof U : never;
+/** CSS properties, less any a utility of the same name replaces (the compiler reads utilities first). */
+type StyleProperties = [Extract<UtilityNames, keyof CssProperties>] extends [never] ? CssProperties : Omit<CssProperties, UtilityNames>;
+/**
+ * Utilities as style keys. Before generation the project's own utilities are
+ * unknown, so any other key is accepted too.
+ */
+type UtilityProperties = Register extends {
+  utilities: infer U;
+} ? { [K in keyof U]?: ConditionalValue<UtilityValue<U[K]>>; } : OpenUtilityProperties;
+interface OpenUtilityProperties {
+  size?: ConditionalValue<ScaleValue<"sizes">>;
+  truncate?: ConditionalValue<boolean>;
+  srOnly?: ConditionalValue<boolean>;
+  readonly [utility: string]: unknown;
+}
+/**
+ * Blocks under a condition. Before generation the conditions are a pattern,
+ * an index signature that a marker's computed key meets too, so it takes
+ * any value as `StyleObject`'s marker signature does, and `ExactStyle`
+ * checks the blocks.
+ */
+type ConditionBlocks = `_${string}` extends Conditions ? OpenConditionBlocks : { [C in Conditions]?: StyleObject; };
+interface OpenConditionBlocks {
+  readonly [condition: `_${string}`]: StyleObject | AnyStyleValue | undefined;
+}
+/**
+ * A style object as authors write it (PLAN §4.2): CSS properties typed by
+ * their scales, utilities, `textStyle`, and blocks under a condition or a
+ * marker.
+ */
+interface StyleObject extends StyleProperties, UtilityProperties, ConditionBlocks {
+  /** A composite token from `textStyles` in the config. */
+  textStyle?: ConditionalValue<TextStyles>;
+  /**
+   * The palette `palette.*` colours follow on this element and its subtree
+   * (PLAN §4.8): `colorPalette: "red"` makes `palette.600` read `red.600`.
+   */
+  colorPalette?: ConditionalValue<Palette>;
+  /**
+   * A block under a marker. A marker's key is computed, which gives the
+   * object literal a `string` index signature over every value in it, the
+   * named properties' included, so the signature takes any value a style
+   * holds: `ExactStyle` checks what sits under a marker as a block.
+   */
+  readonly [marker: MarkerKey]: StyleObject | AnyStyleValue | undefined;
+}
+/** Any value a property takes, as `css()` would before the design system types it. */
+type AnyStyleValue = ConditionalValue<string | number | boolean>;
+/** Keys whose value is a nested block: conditions and markers. */
+type BlockKey = Conditions | MarkerKey;
+/** Named in errors on a key that is no style key. */
+interface UnknownStyleKey {
+  readonly "vicss: not a CSS property, a utility, textStyle or a condition": never;
+}
+/** Named in errors on a key of a value per condition that is neither `base` nor a condition. */
+interface UnknownConditionKey {
+  readonly "vicss: not base or a condition": never;
+}
+/**
+ * Excess-property checks for an inferred style object, which TypeScript
+ * skips for a type parameter. `unknown` when every key is known, at every
+ * depth; otherwise a path to each unknown key, whose value must be
+ * `UnknownStyleKey` (or `UnknownConditionKey`), which no value is. Only the
+ * keys at fault are mapped: a mapped type over every key of every style
+ * would be checked against each argument (tests/types/budget.test.ts).
+ */
+type ExactStyle<S> = [BadKeys<S>] extends [never] ? unknown : { [K in BadKeys<S>]: K extends MarkerKey ? MarkerCheck<S> : K extends keyof StyleObject ? K extends BlockKey ? OpenBlock & ExactStyle<S[K & keyof S]> : ExactValue<S[K & keyof S]> : UnknownStyleKey; };
+/** What a named block is checked against besides its keys: `StyleObject` before generation (`BadNamedBlock`). */
+type OpenBlock = `_${string}` extends Conditions ? StyleObject : unknown;
+type ExactValue<V> = [BadConditionKeys<V>] extends [never] ? unknown : { [K in BadConditionKeys<V>]: K extends "base" | BlockKey ? ExactValue<V[K & keyof V]> : UnknownConditionKey; };
+/**
+ * Keys of `S` that are unknown, or hold a block or a value per condition
+ * with an unknown key; `MarkerKey` when a block under a marker is at fault.
+ */
+type BadKeys<S> = Exclude<Known<S>, keyof StyleObject> | { [K in BlockKeys<S>]-?: [BadNamedBlock<S[K & keyof S]>] extends [never] ? never : K; }[BlockKeys<S>] | { [K in ValueKeys<S>]-?: [BadConditionKeys<S[K & keyof S]>] extends [never] ? never : K; }[ValueKeys<S>] | (string extends keyof S ? (true extends BadBlock<Computed<S>> ? MarkerKey : never) : never);
+type BadConditionKeys<V> = Exclude<Known<V>, "base" | BlockKey> | { [K in Known<V>]-?: V[K & keyof V] extends object ? [BadConditionKeys<V[K & keyof V]>] extends [never] ? never : K : never; }[Known<V>];
+/**
+ * The keys of `S` written by name. A computed key of a pattern type (a
+ * marker's `[row.hover]`) gives the object a `string` index signature,
+ * which `keyof` folds every named key into; a remapped type lists them
+ * again. Only objects with a marker pay for it.
+ */
+type Known<S> = string extends keyof S ? keyof { [K in keyof S as Named<K>]: 0; } : keyof S;
+/** Keys that name a property: not the `string` and `number` of an index signature. */
+type Named<K> = K extends unknown ? string extends K ? never : number extends K ? never : K : never;
+/**
+ * The blocks of `S` under computed keys, its markers'. The index signature
+ * covers every value, so those of named keys are taken out: values both
+ * ways assignable to one, since dropping what is merely assignable would
+ * also drop a block that adds keys to a named one, and leave them
+ * unchecked. TypeScript normalizes a union of object literals with
+ * `key?: undefined` for the keys of the others, which `Written` drops.
+ */
+type Computed<S> = Written<Unnamed<S[string & keyof S], ValuesAt<S, Known<S>>>>;
+/** An object without the `key?: undefined` that union normalization added. */
+type Written<B> = B extends object ? { [K in keyof B as [B[K]] extends [undefined] ? never : K]: B[K]; } : B;
+/** `S[K]`, distributed: `S[never]` is the index signature's value on an object that has one. */
+type ValuesAt<S, K> = K extends keyof S ? S[K] : never;
+type Unnamed<U, N> = U extends unknown ? (true extends SameAs<U, N> ? never : U) : never;
+type SameAs<A, N> = N extends unknown ? [A] extends [N] ? [N] extends [A] ? true : never : never : never;
+/**
+ * `true` for a block under a named condition that `css()` refuses. With a
+ * registered design system each condition is a property typing its block,
+ * which the argument is checked against; before, the conditions are a
+ * pattern whose signature takes any value (`ConditionBlocks`), so the
+ * block's values are checked here too. Only then: the check costs as much
+ * as the rest of `css()`'s (tests/types/budget.test.ts).
+ */
+type BadNamedBlock<B> = `_${string}` extends Conditions ? BadBlock<B> : [BadKeys<B>] extends [never] ? never : true;
+/** `true` for a block under a marker that `css()` refuses: a value no style takes, or an unknown key. */
+type BadBlock<B> = B extends unknown ? [B] extends [StyleObject] ? [BadKeys<B>] extends [never] ? never : true : true : never;
+/**
+ * What the index signature a marker gives `S` must hold where a block is at
+ * fault: the values of its named properties, which the signature covers
+ * too, or a block that is a style with every block's keys checked. The
+ * blocks themselves are intersected in: TypeScript types a value under a
+ * marker by this signature alone, and would widen the literals it does not
+ * list, then report them before the fault.
+ */
+type MarkerCheck<S> = ValuesAt<S, Exclude<Known<S>, BlockKey>> | (BlocksOf<S> & StyleObject & AllExact<BlocksOf<S>>);
+/** The blocks of `S`, under conditions and markers. */
+type BlocksOf<S> = ValuesAt<S, BlockKeys<S>> | (string extends keyof S ? Computed<S> : never);
+/** `ExactStyle` of each block, intersected: a union would let one block pass another's check. */
+type AllExact<B> = (B extends object ? (check: ExactStyle<B>) => void : never) extends ((check: infer I) => void) ? I : unknown;
+type BlockKeys<S> = Extract<Known<S>, BlockKey>;
+/** Keys of `S` holding a value per condition (an object). */
+type ValueKeys<S> = { [K in Exclude<Known<S>, BlockKey>]-?: S[K & keyof S] extends object ? K : never; }[Exclude<Known<S>, BlockKey>];
+/**
+ * The keys a style object sets: properties, utilities and `textStyle`, with
+ * those of nested blocks, under conditions and markers. Unrolled to three
+ * levels of nesting rather than recursive, which the checker would expand
+ * without end on `StyleObject` itself; anything deeper counts as setting
+ * any property. Most styles have no block, which the first test answers
+ * without looking further.
+ */
+type PropsOf<S> = Recorded<KeysSet<S>>;
+/** `PropsOf` before utilities are replaced by what they set: one `Recorded` serves many styles. */
+type KeysSet<S> = [BlockKeys<S>] extends [never] ? string extends keyof S ? (OwnKeys<S> | Nested1<Computed<S>>) & string : keyof S & string : (OwnKeys<S> | Nested1<BlocksOf<S>>) & string;
+/** The keys a style sets itself, not in its blocks. */
+type OwnKeys<S> = Exclude<Known<S>, BlockKey>;
+type Nested1<B> = B extends object ? OwnKeys<B> | Nested0<BlocksOf<B>> : never;
+type Nested0<B> = B extends object ? OwnKeys<B> | ([BlocksOf<B>] extends [never] ? never : string) : never;
+/** Records the keys a compiled style sets; never present at runtime. */
+declare const PROPERTIES: unique symbol;
+/**
+ * A compiled style (PLAN §4.7, §5.6): an object from merge id to class name
+ * that records the keys it sets. `Style<"margin" | "width">` accepts
+ * `css({ margin: 4 })` and rejects `css({ color: "accent" })`, so a
+ * component decides what a caller may override. A utility or `textStyle`
+ * counts as the properties it sets.
+ *
+ * One style is an element's class and its style (PLAN §5.16): its
+ * `toString()` is its class attribute, so it goes where a class string
+ * goes (`class={card}`, `className={card}`, `${card}`), and the plugin
+ * writes it as an inline style where it is `style=`. The type says so: a
+ * string that records its keys, which `className` and `class` take, and
+ * which React's `style` takes too through one property it shares with
+ * React's style object (always `undefined`: the value is no style object).
+ * At runtime it is an object, not a string: `String(card)` is its classes,
+ * and string methods are not there.
+ */
+type Style<K extends string = string> = string & {
+  readonly [PROPERTIES]: K;
+  /** Never set: what lets React's `style` prop take a compiled style, which the plugin writes inline. */
+  readonly WebkitBoxOrient?: undefined;
+};
+/**
+ * A compiled style with runtime values (PLAN §5.8): its constant style and
+ * the custom properties its classes read, which `sx()` sets inline.
+ */
+interface DynamicStyle<K extends string = string> {
+  readonly $c: Style<K>;
+  readonly $s?: Readonly<Record<string, string>>;
+}
+/**
+ * What `sx()` takes: compiled styles, the app's own class names (a string,
+ * kept as it is, before the styles' classes), falsy values (`cond && style`)
+ * and arrays of them.
+ */
+type StyleArg<K extends string = string> = Style<K> | DynamicStyle<K> | string | false | null | undefined | 0 | readonly StyleArg<K>[];
+/** The attributes `sx()` returns in this project: `SxAttributes` of the registered framework. */
+type StyleAttributes = SxAttributes;
+/** A function style (PLAN §4.6): runtime values in, a style object out. */
+type StyleFunction = (...args: never[]) => StyleObject;
+/**
+ * `ExactStyle` for a style object, or for the object a function style
+ * returns. Nothing while `S` is still the constraint: the checker types the
+ * argument's properties against the parameter before it infers `S`, and an
+ * intersection there would rebuild each property's token union per call.
+ */
+type Exact<S> = StyleObject extends S ? unknown : S extends ((...args: infer A) => infer R) ? (...args: A) => R & ExactStyle<R> : ExactStyle<S>;
+/** What `css()` compiles `S` to: a style, or a function returning a dynamic style. */
+type CssResult<S> = S extends ((...args: infer A) => infer R) ? (...args: A) => DynamicStyle<PropsOf<R>> : Style<PropsOf<S>>;
+/** What `css()` takes besides the style. */
+interface CssOptions {
+  /**
+   * A class the style adds as it is (`card`), kept like a class string
+   * passed to `sx()`: a stable hook for tests, theming and devtools, which
+   * the style's own classes, hashed in builds, are not.
+   */
+  readonly name?: string;
+}
+/**
+ * `css()`: a style object, or a function style, checked against the design
+ * system. One signature rather than overloads, so an error names the
+ * property at fault instead of the overload tried last. `const` keeps each
+ * literal's type without asking whether its contextual type is a literal
+ * type, which on a value per condition of a large scale costs a pass over
+ * the scale's union per value (tests/types/budget.test.ts).
+ */
+type Css = <const S extends StyleObject | StyleFunction>(style: S & NoInfer<Exact<S>>, options?: CssOptions) => CssResult<S>;
+/** `sx()`: merges styles into the attributes of an element, in the project's framework's shape. */
+type Sx = (...args: StyleArg[]) => SxAttributes;
+/**
+ * States a marker exposes as condition keys (`[row.hover]`): the conditions
+ * on the element itself, which `vicss.d.ts` lists from the config, its own
+ * (`"&[aria-current=page]"`) included. Before generation, the built-in ones.
+ */
+type MarkerState = Register extends {
+  markerStates: infer S extends string;
+} ? S : BuiltInMarkerState;
+/** The built-in conditions a marker takes, structural ones included. */
+type BuiltInMarkerState = "first" | "last" | "only" | "odd" | "even" | "firstOfType" | "lastOfType" | "visited" | "target" | "open" | "checked" | "indeterminate" | "placeholderShown" | "autofill" | "optional" | "required" | "valid" | "invalid" | "readOnly" | "empty" | "focusWithin" | "hover" | "focus" | "focusVisible" | "active" | "enabled" | "disabled";
+/**
+ * `group()` / `peer()`: the class that marks an element (`sx(row, …)`), which
+ * sets no property, so any `Style` prop takes it. Its states are condition
+ * keys in styles compiled with it (PLAN §4.5); they exist at build time only:
+ * at runtime a marker is a style that adds its class as it is (`$n`).
+ */
+type Marker = Style<never> & { readonly [State in MarkerState]: MarkerKey; };
+/**
+ * Types the definition only, never the runtime: the phantom key ties a
+ * `Recipe` to the shape of the definition it came from (`RecipeShape`), so
+ * `extends` and `Variants` can read it back. Nothing at runtime carries it.
+ */
+declare const definitionKey: unique symbol;
+/** A variant value as props and compounds name it: `true` names the `"true"` value. */
+type VariantValue = string | number | boolean;
+/** A slot recipe's style per slot: `{ panel: { … }, title: { … } }`. */
+interface SlotStyles {
+  readonly [slot: string]: SlotStyle;
+}
+/**
+ * A style in a slot. No style has a `base` key; saying so keeps a value per
+ * condition (`{ color: { base: "nope" } }`) in a recipe without slots from
+ * reading as a style for a slot named `color`, which TypeScript would report
+ * as a missing `slots` rather than at the value.
+ */
+interface SlotStyle extends StyleObject {
+  readonly base?: undefined;
+}
+/**
+ * A compound variant: the values it holds for (a value or a list) and the
+ * style it adds, a style per slot in a slot recipe.
+ */
+interface CompoundVariant<S = StyleObject> {
+  readonly style: S;
+  readonly [variant: string]: VariantValue | readonly VariantValue[] | S;
+}
+/** A compound slot: one style for several slots, when the variants hold. */
+interface CompoundSlot {
+  readonly slots: readonly string[];
+  readonly style: StyleObject;
+  readonly [variant: string]: VariantValue | readonly VariantValue[] | StyleObject;
+}
+/** What `extends` takes: a recipe made by `recipe()`. */
+interface RecipeLike {
+  readonly [definitionKey]?: RecipeShape;
+}
+/** A parent with slots: a recipe extends parents of one kind only (the compiler refuses a mix). */
+interface SlotRecipeLike {
+  readonly [definitionKey]?: {
+    readonly slots: {
+      readonly [slot: string]: string;
+    };
+  };
+}
+interface DefinitionBase {
+  readonly defaultVariants?: Readonly<Record<string, VariantValue>>;
+  /** Variants whose props may take a value per breakpoint or container; `true` for all. */
+  readonly responsive?: readonly string[] | true;
+}
+/**
+ * `recipe()`'s argument (PLAN §4.4): every style is a `StyleObject`,
+ * checked against the design system like a `css()` style. Boolean variants
+ * use the keys `true` and `false`. With slots, of its own or a parent's,
+ * base styles live in the slots and every value and compound styles slots
+ * (`{ panel: { … } }`). Three members rather than one whose values take a
+ * style or a style per slot: a style per slot would also read as a style
+ * with an unknown key (`panel`), and its values would escape the check.
+ * `DefinitionFor` picks the member a definition is checked against.
+ */
+type RecipeDefinition = SlotDefinition | InheritedSlotsDefinition | PlainDefinition;
+interface SlotsBase extends DefinitionBase {
+  readonly base?: undefined;
+  /**
+   * Slots whose base style compiles to one class (PLAN D22): `true` for
+   * every slot, a list for those. Left out, the parents' choice holds.
+   */
+  readonly flatten?: boolean | readonly string[];
+  /** Variant → value → style per slot. */
+  readonly variants?: {
+    readonly [variant: string]: {
+      readonly [value: string]: SlotStyles;
+    };
+  };
+  readonly compoundVariants?: readonly CompoundVariant<SlotStyles>[];
+  readonly compoundSlots?: readonly CompoundSlot[];
+}
+/** A recipe with slots of its own, and parents with slots, if any. */
+interface SlotDefinition extends SlotsBase {
+  readonly slots: SlotStyles;
+  readonly extends?: SlotRecipeLike | readonly SlotRecipeLike[];
+}
+/** A recipe whose slots come from its parents, perhaps with more of its own. */
+interface InheritedSlotsDefinition extends SlotsBase {
+  readonly slots?: SlotStyles;
+  readonly extends: SlotRecipeLike | readonly SlotRecipeLike[];
+}
+interface PlainDefinition extends DefinitionBase {
+  readonly base?: StyleObject;
+  /**
+   * The base compiles to one class (PLAN D22), for an element repeated
+   * thousands of times: every variant, compound and `sx()` override still
+   * wins over it per property and condition, as over atoms. Left out, the
+   * parents' choice holds.
+   */
+  readonly flatten?: boolean;
+  readonly slots?: undefined;
+  /** Variant → value → style. */
+  readonly variants?: {
+    readonly [variant: string]: {
+      readonly [value: string]: StyleObject;
+    };
+  };
+  readonly compoundVariants?: readonly CompoundVariant[];
+  readonly compoundSlots?: undefined;
+  /**
+   * Parents merged before this definition: variants per key, compounds
+   * first. Any recipe whose type declares no slots, a bare `Recipe` and a
+   * shape written by hand included: `DefinitionFor` picks this member only
+   * when no parent declares slots.
+   */
+  readonly extends?: RecipeLike | readonly RecipeLike[];
+}
+/**
+ * What `recipe()` infers a definition against: its shape, with any object
+ * for a style. A fault in one style then leaves the definition's type to
+ * the literal, so the recipe keeps its variants, and the fault is reported
+ * where it is, against the member `DefinitionFor` picks; against the union,
+ * TypeScript would report it at every value, against whichever member it
+ * tried last.
+ */
+interface DefinitionShape extends DefinitionBase {
+  readonly base?: object;
+  readonly flatten?: boolean | readonly string[];
+  readonly slots?: {
+    readonly [slot: string]: object;
+  };
+  readonly variants?: {
+    readonly [variant: string]: {
+      readonly [value: string]: object;
+    };
+  };
+  readonly compoundVariants?: readonly object[];
+  readonly compoundSlots?: readonly object[];
+  readonly extends?: RecipeLike | readonly RecipeLike[];
+}
+/**
+ * `recipe()`'s parameter for definition `D`: `D` itself where it is the
+ * `RecipeDefinition` member `DefinitionFor` picks, that member where a
+ * style is not, which TypeScript then reports at the value at fault; `D`
+ * stays the literal either way. Not the two intersected: TypeScript looks
+ * a property up in `D` alone where the member has an index signature
+ * instead, and reports nothing below it, and a literal value met with a
+ * property's values is `never`, which is all its message would name.
+ */
+type DefinitionArg<D> = [D] extends [DefinitionFor<D>] ? D : DefinitionFor<D>;
+/**
+ * The member of `RecipeDefinition` that definition `D` is checked against:
+ * with slots when it has its own, or its parents declare theirs; without
+ * slots otherwise.
+ */
+type DefinitionFor<D> = D extends {
+  readonly slots: object;
+} ? SlotDefinition : [KeysOfUnion<ParentSlots<ParentsOf<D>>>] extends [never] ? PlainDefinition : InheritedSlotsDefinition;
+/**
+ * What a recipe's type keeps of its definition: the names of its variants
+ * and values, its slots, `responsive`, its parents, and the properties its
+ * styles set, which `Style<K>` props check; never its values or
+ * conditions. A recipe's type, and the declarations a library ships, grow
+ * with its table.
+ */
+interface RecipeShape {
+  readonly variants?: {
+    readonly [variant: string]: {
+      readonly [value: string]: unknown;
+    };
+  } | undefined;
+  /** Slot → the properties its styles set, parents' slots included; `undefined` without slots. */
+  readonly slots?: {
+    readonly [slot: string]: string;
+  } | undefined;
+  /** The properties the styles of a recipe without slots set, parents' included. */
+  readonly props?: string | undefined;
+  readonly responsive?: readonly string[] | true | undefined;
+  readonly extends?: RecipeLike | readonly RecipeLike[] | undefined;
+}
+/**
+ * A definition's `RecipeShape`: `1` stands for a value's styles. A
+ * conditional type, so declarations print the shape rather than
+ * `ShapeOf<definition>`.
+ */
+type ShapeOf<D> = D extends unknown ? {
+  readonly variants: D extends {
+    readonly variants: infer V;
+  } ? { readonly [K in keyof V]: { readonly [Value in keyof V[K]]: 1; }; } : undefined;
+  readonly slots: [SlotNames<D>] extends [never] ? undefined : { readonly [K in SlotNames<D>]: SlotProps<D, K>; };
+  readonly props: [SlotNames<D>] extends [never] ? PlainProps<D> : undefined;
+  readonly responsive: D extends {
+    readonly responsive: infer R;
+  } ? R : undefined;
+  readonly extends: D extends {
+    readonly extends: infer E;
+  } ? E : undefined;
+} : never;
+type DefinitionOf<R> = R extends {
+  readonly [definitionKey]?: infer D;
+} ? Exclude<D, undefined> : never;
+type ParentsOf<D> = D extends {
+  readonly extends: infer E;
+} ? DefinitionOf<E extends readonly unknown[] ? E[number] : E> : never;
+/** The string keys of an object; none of `undefined`. */
+type KeysIn<T> = T extends object ? keyof T & string : never;
+/** Variant names of a shape and its parents; `string` for the bare `RecipeShape`. */
+type KeysOf<D> = D extends unknown ? (D extends {
+  readonly variants?: infer V;
+} ? KeysIn<V> : never) | KeysOf<ParentsOf<D>> : never;
+/** The values of variant `K`, as the definitions key them. */
+type ValuesOf<D, K> = D extends unknown ? (D extends {
+  readonly variants?: infer V;
+} ? V extends object ? K extends keyof V ? keyof V[K] : never : never : never) | ValuesOf<ParentsOf<D>, K> : never;
+/** A list that is not literal (`string[]`) names no variant the types can know. */
+type ResponsiveOf<D> = D extends unknown ? (D extends {
+  readonly responsive: true;
+} ? KeysOf<D> : D extends {
+  readonly responsive: readonly (infer R)[];
+} ? string extends R ? never : R : never) | ResponsiveOf<ParentsOf<D>> : never;
+/**
+ * The parents' shapes record their slots and properties, their own parents'
+ * included, so a definition reads one level up and never walks further.
+ */
+type ParentSlots<P> = P extends {
+  readonly slots: infer S extends object;
+} ? S : never;
+type ParentProps<P> = P extends {
+  readonly props: infer X;
+} ? X : never;
+/** A definition's slots: its own and its parents'. */
+type SlotNames<D> = (D extends {
+  readonly slots: infer S;
+} ? KeysIn<S> : never) | KeysOfUnion<ParentSlots<ParentsOf<D>>>;
+type KeysOfUnion<T> = T extends unknown ? keyof T & string : never;
+/** `KeysSet` of each style in a union: `keyof` a union would keep only the shared keys. */
+type KeysOfStyles<S> = S extends unknown ? KeysSet<S> : never;
+/** Variant values: each value's style (a style per slot in a slot recipe). */
+type Cells<D> = D extends {
+  readonly variants: infer V;
+} ? { [K in keyof V]: V[K][keyof V[K]]; }[keyof V] : never;
+type Compounds<D> = D extends {
+  readonly compoundVariants: readonly (infer C)[];
+} ? C : never;
+type StyleIn<C> = C extends {
+  readonly style: infer S;
+} ? S : never;
+/** The style a cell (a style per slot) gives slot `K`. */
+type SlotCell<C, K> = C extends unknown ? (K extends keyof C ? C[K] : never) : never;
+/** The style of each compound slot that names slot `K`. */
+type CompoundSlotStyle<D, K> = D extends {
+  readonly compoundSlots: readonly (infer C)[];
+} ? C extends {
+  readonly slots: readonly (infer N)[];
+  readonly style: infer S;
+} ? K extends N ? S : never : never : never;
+/** What a recipe without slots sets: its base, values and compounds, and its parents'. */
+type PlainProps<D> = Recorded<KeysOfStyles<(D extends {
+  readonly base: infer B;
+} ? B : never) | Cells<D> | StyleIn<Compounds<D>>>> | ParentProps<ParentsOf<D>>;
+/** What slot `K` of a slot recipe sets: in its slot style, values, compounds and compound slots. */
+type SlotProps<D, K> = Extract<Recorded<KeysOfStyles<(D extends {
+  readonly slots: infer S;
+} ? SlotCell<S, K> : never) | SlotCell<Cells<D>, K> | SlotCell<StyleIn<Compounds<D>>, K> | CompoundSlotStyle<D, K>>> | SlotCell<ParentSlots<ParentsOf<D>>, K>, string>;
+/** `"true"`/`"false"` keys take booleans; numeric keys take the number or its string. */
+type PropValue<T> = T extends "true" | "false" ? boolean : T extends number ? T | `${T}` : T;
+/**
+ * The conditions a responsive prop takes: min-width breakpoints and
+ * container sizes, which `vicss.d.ts` lists. Before generation, any `_` key.
+ */
+type ResponsiveConditions = Register extends {
+  responsive: infer C extends string;
+} ? C : `_${string}`;
+/**
+ * A responsive prop: a value, or a value per breakpoint or container
+ * condition, mobile-first (`{ base: "sm", _md: "lg" }`). `null` and
+ * `undefined` leave a value to the default or the condition below.
+ */
+type ResponsiveValue<V> = V | { [C in "base" | ResponsiveConditions]?: V | null | undefined; };
+/**
+ * Whether `D` says nothing about a recipe: the bare `Recipe` type, which every
+ * recipe must be assignable to. Its props are `never` (a caller that does not
+ * know the variants can only call it without props) and its keys `string`.
+ */
+type Unknown<D> = string extends KeysOf<D> ? true : false;
+/**
+ * The props of a recipe with shape `D`: every variant, optional. `null` and
+ * `undefined` take the default, so `button({ size, block })` forwards
+ * optional props as they are.
+ */
+type RecipeProps<D> = Unknown<D> extends true ? never : { [K in KeysOf<D>]?: (K extends ResponsiveOf<D> ? ResponsiveValue<PropValue<ValuesOf<D, K>>> : PropValue<ValuesOf<D, K>>) | null | undefined; };
+/**
+ * A style that records what the recipe's styles can set, or one per slot:
+ * `sx()` takes it, and so does a `Style<K>` prop when every
+ * property the recipe sets is open to the caller.
+ */
+type RecipeResult<D> = Unknown<D> extends true ? Style | {
+  readonly [slot: string]: Style;
+} : D extends {
+  readonly slots: infer S extends {
+    readonly [slot: string]: string;
+  };
+} ? { readonly [K in keyof S]: Style<S[K]>; } : Style<D extends {
+  readonly props: infer P extends string;
+} ? P : string>;
+/**
+ * A compiled recipe: call it with variant props for classes (PLAN §4.4).
+ * `D` is a `RecipeShape`, unconstrained: with a constraint, an app that
+ * checks its libraries' declarations (`skipLibCheck: false`) would prove
+ * `recipe()`'s `Recipe<ShapeOf<D>>` meets it for a generic definition over
+ * its whole design system, about 1.3 M instantiations before a line of its
+ * own. Every reader of `D` is a conditional type, and `extends` takes a
+ * recipe only when its shape is a `RecipeShape` (`RecipeLike`).
+ */
+interface Recipe<D = RecipeShape> {
+  (props?: RecipeProps<D>): RecipeResult<D>;
+  /** The variant props, for splitting them from DOM props. */
+  readonly variantKeys: ReadonlyArray<KeysOf<D>>;
+  /** `[variantProps, rest]`. */
+  splitProps<P extends object>(props: P): [Pick<P, Extract<keyof P, KeysOf<D>>>, Omit<P, KeysOf<D>>];
+  /** Every variant's values and the defaults, as strings, for docs and Storybook. */
+  readonly schema: {
+    readonly variants: Readonly<Record<KeysOf<D>, readonly string[]>>;
+    readonly defaults: Readonly<Partial<Record<KeysOf<D>, string>>>;
+  };
+  readonly [definitionKey]?: D;
+}
+/** The props a recipe takes: `Variants<typeof button>`. */
+type Variants<R extends RecipeLike> = RecipeProps<DefinitionOf<R>>;
+/** What variant `K` of shape `S` takes: a value, or a list of them (`many`); `never` for no variant. */
+type Allowed<S, K, Many> = K extends KeysOf<S> ? Many extends true ? PropValue<ValuesOf<S, K>> | readonly PropValue<ValuesOf<S, K>>[] : PropValue<ValuesOf<S, K>> : never;
+/**
+ * `unknown` when `Actual` is allowed, else what is: a check intersected with
+ * the definition costs nothing where it holds, and intersecting arrays (a
+ * compound's value list) would instantiate every array method.
+ */
+type Check<Actual, A> = [Actual] extends [A] ? unknown : A;
+/** Whether every key of compound `E` names a variant of `S` and its values, besides `reserved`. */
+type CompoundValid<S, E, Reserved> = E extends unknown ? { [P in keyof E]-?: P extends Reserved ? true : [E[P]] extends [Allowed<S, P, true>] ? true : false; }[keyof E] : never;
+/** A list of compounds checked entry by entry, once one is wrong. */
+type CompoundsCheck<S, C, Reserved> = C extends readonly unknown[] ? false extends CompoundValid<S, C[number], Reserved> ? { readonly [I in keyof C]: { readonly [P in keyof C[I]]: P extends Reserved ? unknown : Check<C[I][P], Allowed<S, P, true>>; }; } : unknown : unknown;
+/** Named in errors on a key of a style per slot that is no slot of the recipe. */
+interface UnknownSlot {
+  readonly "vicss: not a slot of this recipe": never;
+}
+/**
+ * Whether a style of the definition has a key `css()` would refuse
+ * (`ExactStyle`), or a style per slot names no slot. Distributes over
+ * every style at once, so a valid definition costs one pass.
+ */
+type Faulty<D, Slots> = D extends unknown ? AnyBadKeys<(D extends {
+  readonly base: infer B;
+} ? B : never) | (D extends {
+  readonly slots: infer S;
+} ? S[keyof S] : never) | ([Slots] extends [never] ? Cells<D> | StyleIn<Compounds<D>> : SlotValues<Cells<D> | StyleIn<Compounds<D>>>) | StyleIn<D extends {
+  readonly compoundSlots: readonly (infer C)[];
+} ? C : never>> | ([Slots] extends [never] ? never : AnyBadSlot<Cells<D> | StyleIn<Compounds<D>>, Slots>) : never;
+type SlotValues<C> = C extends unknown ? C[keyof C] : never;
+type AnyBadKeys<S> = S extends unknown ? ([BadKeys<S>] extends [never] ? never : true) : never;
+type AnyBadSlot<C, Slots> = C extends unknown ? [Exclude<keyof C, Slots>] extends [never] ? never : true : never;
+/** `ExactStyle` of a value's or a compound's style, or of each slot's. */
+type CellCheck<C, Slots> = [Slots] extends [never] ? ExactStyle<C> : { readonly [K in keyof C]: K extends Slots ? ExactStyle<C[K]> : UnknownSlot; };
+/** The definition's styles, each checked: built only for a definition that has a fault. */
+type StylesCheck<D, Slots> = {
+  readonly base?: D extends {
+    readonly base: infer B;
+  } ? ExactStyle<B> : unknown;
+  readonly slots?: D extends {
+    readonly slots: infer S;
+  } ? { readonly [K in keyof S]: ExactStyle<S[K]>; } : unknown;
+  readonly variants?: D extends {
+    readonly variants: infer V;
+  } ? { readonly [K in keyof V]: { readonly [X in keyof V[K]]: CellCheck<V[K][X], Slots>; }; } : unknown;
+};
+/** The compounds' styles, checked like the values': built only for a definition that has a fault. */
+type CompoundStylesCheck<C, Slots> = C extends readonly unknown[] ? { readonly [I in keyof C]: {
+  readonly style: CellCheck<StyleIn<C[I]>, Slots>;
+}; } : unknown;
+/**
+ * What `recipe()` checks of a definition beyond its type, against its own
+ * variants and its parents': defaults and compounds name variants and their
+ * values (`never` where they do not), a literal `responsive` list names
+ * variants, and, where some style has a fault, each style's keys, as
+ * `css()` checks them, and the slots a style per slot names. Nothing while
+ * `D` is still the constraint, as for `css()` (`Exact`).
+ */
+type RecipeChecks<D> = ShapeOf<D> extends (infer S) ? {
+  readonly defaultVariants?: D extends {
+    readonly defaultVariants: infer V;
+  } ? { readonly [K in keyof V]: Check<V[K], Allowed<S, K, false>>; } : unknown;
+  readonly compoundVariants?: D extends {
+    readonly compoundVariants: infer C;
+  } ? CompoundsCheck<S, C, "style"> : unknown;
+  readonly compoundSlots?: D extends {
+    readonly compoundSlots: infer C;
+  } ? CompoundsCheck<S, C, "style" | "slots"> : unknown;
+  readonly responsive?: D extends {
+    readonly responsive: readonly (infer R)[];
+  } ? string extends R ? unknown : [R] extends [KeysOf<S>] ? unknown : readonly KeysOf<S>[] : unknown;
+  readonly flatten?: D extends {
+    readonly flatten: readonly (infer F)[];
+  } ? string extends F ? unknown : [F] extends [SlotNames<D>] ? unknown : readonly SlotNames<D>[] : unknown;
+} & (DefinitionShape extends D ? unknown : true extends Faulty<D, SlotNames<D>> ? StylesCheck<D, SlotNames<D>> & {
+  readonly compoundVariants?: D extends {
+    readonly compoundVariants: infer C;
+  } ? CompoundStylesCheck<C, SlotNames<D>> : unknown;
+  readonly compoundSlots?: D extends {
+    readonly compoundSlots: infer C;
+  } ? CompoundStylesCheck<C, never> : unknown;
+} : unknown) : never;
+/** M1's names for the authoring types, kept for code written against them. */
+type StyleInput = StyleObject;
+type StyleInputValue = ConditionalValue<string | number | boolean> | StyleObject;
+//#endregion
+//#region src/runtime/merge.d.ts
+/**
+ * A compiled style as the runtime sees it: merge id → class, plus `$n`, the
+ * classes kept as they are (`css(style, { name })`, markers). The public
+ * types in `types.ts` add what the style sets.
+ */
+interface StyleRecord {
+  readonly [id: string]: string;
+}
+/**
+ * A compiled style with runtime values: its constant style, `$c`, which
+ * keys the cache like any compiled style, and the custom properties its
+ * classes read, `$s`, set inline on every call.
+ */
+interface DynamicStyle$1 {
+  readonly $c: StyleRecord;
+  readonly $s?: Readonly<Record<string, string>>;
+}
+/**
+ * What `sx()` takes: compiled styles, class names of the app's own (a
+ * string, kept as it is), falsy values (`cond && style`) and arrays.
+ */
+type StyleArg$1 = string | StyleRecord | DynamicStyle$1 | false | null | undefined | 0 | readonly StyleArg$1[];
+type Vars = Record<string, string>;
+/** Attributes for Solid and Vue: `style` as an object. */
+declare const sxClass: (...args: StyleArg$1[]) => {
+  class: string;
+  style?: Vars;
+};
+/** Attributes for Svelte, Astro and vanilla JS: `style` as `a:b;c:d`. */
+declare const sxString: (...args: StyleArg$1[]) => {
+  class: string;
+  style?: string;
+};
+//#endregion
+//#region src/runtime/uncompiled.d.ts
+/**
+ * A style object compiled to a style (merge id → class) that records the
+ * keys it sets; a function style compiles to a function returning that
+ * style and the custom properties its classes read. `{ name: "card" }` adds
+ * the class `card` as it is.
+ */
+export declare const css: Css;
+/**
+ * Variants, compound variants, slots and responsive variants compiled to
+ * class tables. `const` keeps the definition's literal keys, which type the
+ * props: `recipe({ variants: { size: { sm: {…} } } })` takes `{ size?: "sm" }`.
+ * Its styles are checked against the design system as `css()` checks them,
+ * and a call returns a style that records the properties they set.
+ */
+export declare function recipe<const D extends DefinitionShape>(definition: DefinitionArg<D> & NoInfer<RecipeChecks<D>>): Recipe<ShapeOf<D>>;
+/**
+ * Token paths of one scale (nested groups or dotted) → a value, or a value per
+ * mode (`{ base: "…", _dark: "…" }`), as the compiler accepts them. The paths
+ * stay strings: typing nested groups would take a grammar over token paths.
+ */
+type ThemeTree = {
+  readonly [name: string]: string | number | ThemeTree;
+};
+/** Token overrides for a subtree, as a class that sets no property (`theme({ colors: { accent: "{colors.red.600}" } })`). */
+export declare function theme(overrides: { readonly [S in ScaleName]?: ThemeTree; }): Style<never>;
+/**
+ * A typed `group` marker: its states are conditions on descendants. `name`
+ * identifies a marker that no `const` names, or replaces the const's name.
+ */
+export declare function group(name?: string): Marker;
+/** A typed `peer` marker: its states are conditions on following siblings. */
+export declare function peer(name?: string): Marker;
+/** An `@keyframes` rule; returns the animation name. */
+export declare function keyframes(frames: {
+  readonly [frame: string]: StyleObject;
+}): string;
+/** A token reference as a CSS value: `token("colors.accent")` is `var(--color-accent)`. */
+export declare function token(path: string): string;
+//#endregion
+//#region src/runtime/style.d.ts
+declare class Styled {
+  /**
+   * The class attribute `sx(style)` sets, by `sx()`'s own merge and cache:
+   * the same string by construction, a cache hit after the first render,
+   * and 31 B less than a merge of its own beside `sx()`, which nearly every
+   * app ships (PLAN §6).
+   */
+  toString(this: StyleRecord): string;
+}
+/** What the compiler wraps a compiled style literal in (`__vxStyled({…})`). */
+declare const styled: <T extends object>(record: T) => T & Styled;
+/**
+ * The classes of `sx(...args)`, as a string: what a `style=` value's
+ * conditional properties add to the element's own class (core/attributes.ts).
+ */
+declare const classList: (...args: StyleArg$1[]) => string;
+/**
+ * A framework's class normaliser that reads an object as a map from class
+ * to condition (Vue's `normalizeClass`, Svelte's `clsx`), made to take a
+ * compiled style as its classes: the plugin points the compiled
+ * components' calls at it (vite/attributes.ts).
+ */
+declare const classWith: <A extends unknown[], R>(normalize: (value: unknown, ...rest: A) => R) => (value: unknown, ...rest: A) => R;
+/**
+ * A framework function that normalises the `class` of the props objects
+ * it takes (Vue's `mergeProps`, `normalizeProps` and `ssrRenderAttrs`,
+ * Svelte's server `attributes`), made to take a compiled style there too.
+ */
+declare const propsWith: <A extends unknown[], R>(merge: (...args: A) => R) => (...args: A) => R;
+/** Svelte's `attribute_effect(element, fn, …)`: the props `fn` returns, as `propsWith` takes them. */
+declare const effectWith: <A extends unknown[], R>(effect: (element: unknown, fn: (...values: never[]) => unknown, ...rest: A) => R) => (element: unknown, fn: (...values: never[]) => unknown, ...rest: A) => R;
+//#endregion
+//#region src/runtime/dev.d.ts
+/** What every dev variant adds. A `data-*` name, which each framework passes through as it is. */
+interface Source {
+  "data-vx-src": string;
+}
+/** A function style's runtime value in dev: as in a build, checked. */
+declare const devValue: (property: string, value: unknown) => unknown;
+/**
+ * A Token-typed parameter's value in dev: what core/compile.ts
+ * `tokenExpression` writes in a build, checked.
+ */
+declare const devToken: (property: string, prefix: string, value: unknown) => string | undefined;
+/** React and Preact: `{ className, style, "data-vx-src" }`. */
+declare const sxDev: (src: string, ...args: StyleArg$1[]) => {
+  className: string;
+  style?: {
+    [x: string]: string;
+  };
+} & Source;
+/** Solid and Vue: `{ class, style, "data-vx-src" }`, `style` an object. */
+declare const sxDevClass: (src: string, ...args: StyleArg$1[]) => {
+  class: string;
+  style?: {
+    [x: string]: string;
+  };
+} & Source;
+/** Svelte, Astro and vanilla JS: `{ class, style, "data-vx-src" }`, `style` a string. */
+declare const sxDevString: (src: string, ...args: StyleArg$1[]) => {
+  class: string;
+  style?: string;
+} & Source;
+/**
+ * Dev only (PLAN §5.16): a `style=` value the compiler could not write as
+ * an inline style. A compiled style there would set nothing a browser
+ * reads (its keys are merge ids), so it fails where the element is
+ * rendered, naming the fix; any other value passes through.
+ */
+declare const styleCheck: <T>(value: T, src: string) => T;
+/**
+ * A framework's style setter that checks its value at `at` first: what the
+ * plugin points a compiled component's calls at in dev
+ * (vite/attributes.ts). With `key`, only when the call sets that attribute
+ * (Astro's `addAttribute(value, "style")`).
+ */
+declare const styleWith: <A extends unknown[], R>(set: (...args: A) => R, at: number, src: string, key?: string) => (...args: A) => R;
+//#endregion
+//#region src/runtime/recipe.d.ts
+/** One table cell: a style, or a style per slot. */
+type Classes = StyleRecord | Readonly<Record<string, StyleRecord>>;
+/** A compound: when it holds, its classes, and for a responsive one its pieces' classes and cut. */
+type CompoundEntry = readonly [when: Readonly<Record<string, readonly string[]>>, classes: Classes, ranges?: Readonly<Record<string, Classes>>, cut?: readonly string[]];
+interface RecipeTable {
+  readonly k: readonly string[];
+  readonly s?: readonly string[];
+  readonly b: Classes;
+  readonly v: Readonly<Record<string, Readonly<Record<string, Classes>>>>;
+  readonly c: readonly CompoundEntry[];
+  readonly d: Readonly<Record<string, string>>;
+  readonly q?: readonly [conditions: readonly string[], breakpoints: number];
+  readonly r?: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, Classes>>>>>>;
+  readonly f?: Readonly<Record<string, StyleRecord>>;
+}
+/** What `recipe.schema` describes, for docs and Storybook: every variant's values, and the defaults. */
+interface RecipeSchema {
+  readonly variants: Readonly<Record<string, readonly string[]>>;
+  readonly defaults: Readonly<Record<string, string>>;
+}
+/** The resolver as the runtime sees it; `Recipe<D>` in types.ts is its typed face. */
+interface CompiledRecipe {
+  (props?: Readonly<Record<string, unknown>>): StyleRecord | Readonly<Record<string, StyleRecord>>;
+  readonly variantKeys: readonly string[];
+  splitProps(props: Readonly<Record<string, unknown>>): [Record<string, unknown>, Record<string, unknown>];
+  readonly schema: RecipeSchema;
+}
+/**
+ * A call's responsive part: adds the `r` cells of its props and returns how
+ * to add a compound. `values` holds each variant's value without conditions.
+ */
+type Responsive = (table: RecipeTable, props: Readonly<Record<string, unknown>>, values: Readonly<Record<string, string>>, cells: Array<Classes | undefined>) => (compound: CompoundEntry) => unknown;
+/**
+ * Dev only: the atoms of every flattened base a resolver was made with, by
+ * class, which `sx()`'s dev variant reads (runtime/dev.ts). Production
+ * builds drop it with the branch that fills it.
+ */
+declare const flatBases: Record<string, StyleRecord>;
+export declare const __vxRecipe: (t: RecipeTable, x?: Responsive) => CompiledRecipe;
+/**
+ * Responsive props (PLAN §4.4): each condition a prop sets adds its value's
+ * `r` cell, in rank order, so values stack mobile-first. A compound that has
+ * ranges is evaluated on each piece of the width axis, cut at the conditions
+ * its `cut` variants' props set, with the values in effect there, and adds
+ * its classes under the range condition of each piece where it holds: that
+ * range outranks every condition that holds anywhere in the piece. `ranges`
+ * keys a piece by its bounds: `",md"` below md, `"md,lg"`, `"lg,"` from lg.
+ */
+export declare const __vxResponsive: Responsive;
+//#endregion
+//#region src/index.d.ts
+/**
+ * `sx()` with the public types: compiled styles and class strings in, the
+ * attributes of the project's framework out. The runtime's own signature
+ * returns React's shape.
+ */
+export declare const sx: Sx;
+//#endregion
+export { type CompoundSlot, type CompoundVariant, type ConditionalObject, type ConditionalValue, type Conditions, type CssOptions, type CssProperties, type CssResult, type DynamicStyle, type Marker, type MarkerKey, type MarkerState, type NumberKind, type Palette, type Recipe, type RecipeDefinition, type RecipeProps, type RecipeResult, type RecipeShape, type Register, type RegisteredFramework, type ResponsiveValue, type ScaleName, type ScaleValue, type Strict, type Style, type StyleArg, type StyleAttributes, type StyleFunction, type StyleInput, type StyleInputValue, type StyleObject, type SxAttributes, type SxShapes, type TextStyles, type Token, type Tokens, type Unscaled, type Utilities, type VariantValue, type Variants, classList as __vxClassList, classWith as __vxClassWith, devToken as __vxDevToken, devValue as __vxDevValue, effectWith as __vxEffectWith, flatBases as __vxFlatBases, propsWith as __vxPropsWith, styleCheck as __vxStyleCheck, styleWith as __vxStyleWith, styled as __vxStyled, sxClass as __vxSxClass, sxDev as __vxSxDev, sxDevClass as __vxSxDevClass, sxDevString as __vxSxDevString, sxString as __vxSxString };