onsystem 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,385 +1,7 @@
-import * as z from "zod";
+import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-lbfW91qB.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
-//#region src/detect.d.ts
-/**
- * How apps import a design-system module, from a package's `exports`:
- * `@midday/ui/button` → `../../packages/ui/src/components/button.tsx`, or a
- * pattern (`@workspace/ui/components/*` → `…/src/components/*.tsx`). A
- * specifier without `*` and a pattern target map every matching file to one
- * module: a package that exports its components from a barrel.
- */
-interface ImportMapping {
-  specifier: string;
-  /** File or pattern relative to the root, with forward slashes. */
-  target: string;
-}
-/** One of several design systems an app uses, and how often its code imports it. */
-interface DesignSystemSource {
-  source: string;
-  components: string[];
-  imports: number;
-}
-//#endregion
-//#region src/config.d.ts
-export declare const RULE_IDS: readonly ["no-hardcoded-color", "no-hardcoded-spacing", "no-hardcoded-radius", "prefer-design-system-component", "no-unknown-component", "no-unknown-prop", "no-unknown-variant", "icon-button-accessible-name"];
-type RuleId = (typeof RULE_IDS)[number];
-declare const severitySchema: z.ZodEnum<{
-  off: "off";
-  warn: "warn";
-  error: "error";
-}>;
-type RuleSeverity = z.infer<typeof severitySchema>;
-declare const ruleOptionsSchema: z.ZodObject<{
-  allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-type RuleOptions = z.infer<typeof ruleOptionsSchema>;
-declare const configSchema: z.ZodObject<{
-  $schema: z.ZodOptional<z.ZodString>;
-  components: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    path: z.ZodString;
-    prefix: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    path: z.ZodString;
-    prefix: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>]>>]>>;
-  docs: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-  tsconfig: z.ZodOptional<z.ZodString>;
-  importPath: z.ZodOptional<z.ZodString>;
-  elements: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  includeDesignSystem: z.ZodOptional<z.ZodBoolean>;
-  rules: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
-    "no-hardcoded-color": "no-hardcoded-color";
-    "no-hardcoded-spacing": "no-hardcoded-spacing";
-    "no-hardcoded-radius": "no-hardcoded-radius";
-    "prefer-design-system-component": "prefer-design-system-component";
-    "no-unknown-component": "no-unknown-component";
-    "no-unknown-prop": "no-unknown-prop";
-    "no-unknown-variant": "no-unknown-variant";
-    "icon-button-accessible-name": "icon-button-accessible-name";
-  }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
-    off: "off";
-    warn: "warn";
-    error: "error";
-  }>, z.ZodTuple<[z.ZodEnum<{
-    off: "off";
-    warn: "warn";
-    error: "error";
-  }>], null>, z.ZodTuple<[z.ZodEnum<{
-    off: "off";
-    warn: "warn";
-    error: "error";
-  }>, z.ZodObject<{
-    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  }, z.core.$strict>], null>]>>>;
-  overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    files: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    rules: z.ZodRecord<z.ZodEnum<{
-      "no-hardcoded-color": "no-hardcoded-color";
-      "no-hardcoded-spacing": "no-hardcoded-spacing";
-      "no-hardcoded-radius": "no-hardcoded-radius";
-      "prefer-design-system-component": "prefer-design-system-component";
-      "no-unknown-component": "no-unknown-component";
-      "no-unknown-prop": "no-unknown-prop";
-      "no-unknown-variant": "no-unknown-variant";
-      "icon-button-accessible-name": "icon-button-accessible-name";
-    }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
-      off: "off";
-      warn: "warn";
-      error: "error";
-    }>, z.ZodTuple<[z.ZodEnum<{
-      off: "off";
-      warn: "warn";
-      error: "error";
-    }>], null>, z.ZodTuple<[z.ZodEnum<{
-      off: "off";
-      warn: "warn";
-      error: "error";
-    }>, z.ZodObject<{
-      allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>], null>]>>;
-  }, z.core.$strict>>>;
-}, z.core.$strict>;
-type Config = z.input<typeof configSchema>;
-/** Identity helper for typed `onsystem.config.ts` files. */
-export declare function defineConfig(config: Config): Config;
-interface TokenSourceConfig {
-  path: string;
-  prefix?: string | undefined;
-}
-interface ResolvedRule {
-  severity: RuleSeverity;
-  options: RuleOptions;
-}
-/** Rule settings for the files that match `files` (root-relative globs). */
-interface ResolvedOverride {
-  files: string[];
-  rules: Partial<Record<RuleId, ResolvedRule>>;
-}
-interface ResolvedConfig {
-  root: string;
-  configFile?: string | undefined;
-  components: string[];
-  exclude: string[];
-  tokens: TokenSourceConfig[];
-  docs: string[];
-  tsconfig?: string | undefined;
-  importPath?: string | undefined;
-  /** Import specifiers for component files, from the `exports` of the package that holds them. */
-  imports?: ImportMapping[] | undefined;
-  /** How the design system was found when the config does not say (`components.json`, a workspace package). */
-  detected?: string | undefined;
-  /**
-   * Several design systems found at once, the most imported first: its components win
-   * where two share a name, and are the ones suggested for native elements.
-   */
-  designSystems?: DesignSystemSource[] | undefined;
-  /** A Tailwind v3 config, which maps color classes to custom properties (`primary` → `hsl(var(--primary))`). */
-  tailwindConfig?: string | undefined;
-  elements: Record<string, string>;
-  /** `check` lints the component files themselves, which it skips by default. */
-  includeDesignSystem: boolean;
-  rules: Record<RuleId, ResolvedRule>;
-  /** Per-file rule settings, applied in order over `rules`. */
-  overrides?: ResolvedOverride[] | undefined;
-  /**
-   * The folder `overrides` globs are relative to, when it is not the root: the workspace
-   * root, for a project that takes its settings from a config there.
-   */
-  base?: string | undefined;
-  /** `components` comes from the config file or `--components`, not from detection or the defaults. */
-  configured?: boolean | undefined;
-  /**
-   * What to tell the user about the config's name: a config file found under its name from
-   * before the rename to onsystem. The CLI prints these once per run, the server logs them once.
-   */
-  deprecations?: string[] | undefined;
-}
-interface LoadConfigOptions {
-  /** Where to look for a config file when `root` and `config` are not given. */
-  cwd?: string;
-  /** Project root. Defaults to the config file's directory, then `cwd`. */
-  root?: string | undefined;
-  /** Explicit config file path. */
-  config?: string | undefined;
-  /**
-   * The folder the config file's paths and globs are written relative to, when it is not
-   * the root: a workspace root whose config a project in it takes on.
-   */
-  base?: string | undefined;
-  /** CLI overrides; replace the config file's values when set. */
-  components?: string[] | undefined;
-  tokens?: string[] | undefined;
-  docs?: string[] | undefined;
-  includeDesignSystem?: boolean | undefined;
-}
-export declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedConfig>;
-/** JSON Schema for editor completion in `onsystem.config.json`. */
-export declare function configJsonSchema(): Record<string, unknown>;
-//#endregion
-//#region src/types.d.ts
-/**
- * The design-system model the server exposes. Everything here is plain JSON so
- * it can be cached on disk and returned as MCP structured content.
- */
-declare const TOKEN_CATEGORIES: readonly ["color", "spacing", "radius", "typography", "shadow", "other"];
-type TokenCategory = (typeof TOKEN_CATEGORIES)[number];
-interface SourceLocation {
-  /** Path relative to the project root, with forward slashes. */
-  file: string;
-  /** 1-based line. */
-  line: number;
-}
-interface Token {
-  /**
-   * Canonical name: the DTCG path for JSON tokens (`color.brand.500`) or the
-   * custom property without its dashes for CSS tokens (`primary`, `radius-md`).
-   */
-  name: string;
-  category: TokenCategory;
-  /** The value with aliases resolved, as authored (`oklch(0.205 0 0)`, `0.5rem`). */
-  value: string;
-  /** Values for other modes or themes, e.g. `{ dark: "oklch(0.922 0 0)" }`. */
-  modes?: Record<string, string>;
-  /** The custom property to reference from CSS, e.g. `--primary`. */
-  cssVar?: string;
-  /**
-   * Tailwind theme key when the token is exposed through `@theme`
-   * (`primary` for `--color-primary`, `md` for `--radius-md`).
-   */
-  tailwind?: string;
-  /** Ready-to-paste usages, most idiomatic first: `bg-primary`, `var(--primary)`. */
-  usage: string[];
-  description?: string;
-  deprecated?: string | true;
-  /** Name of the token this one aliases, if any. */
-  aliasOf?: string;
-  /** Where the value comes from. `tailwind-default` marks Tailwind built-ins such as `--spacing`. */
-  origin?: 'tailwind-default';
-  source: SourceLocation;
-}
-interface PropInfo {
-  name: string;
-  /** TypeScript type as written by the checker, without `| undefined`. */
-  type: string;
-  required: boolean;
-  default?: string;
-  description?: string;
-  /** Allowed values when the type is a finite set of literals. */
-  values?: string[];
-  deprecated?: string | true;
-  /** `variant` when the prop comes from a `cva()` definition. */
-  kind: 'prop' | 'variant';
-}
-interface VariantInfo {
-  /** Variant prop name, e.g. `variant` or `size`. */
-  name: string;
-  values: string[];
-  default?: string;
-  /** Classes applied for each value, straight from the `cva()` config. */
-  classes: Record<string, string>;
-}
-interface CompoundVariantInfo {
-  when: Record<string, string | string[]>;
-  classes: string;
-}
-interface InheritedProps {
-  /** Source text of the type the props come from, e.g. `React.ComponentProps<"button">`. */
-  from: string;
-  count: number;
-  /** Key into `DesignSystemModel.propSets` with the full list of names. */
-  set: string;
-  /** Names in the set marked `@deprecated` (React Aria's `onClick`), left out of summaries. */
-  deprecated?: string[];
-}
-interface ExampleInfo {
-  title?: string;
-  code: string;
-  lang: string;
-  source: 'docs' | 'jsdoc';
-}
-interface DocSection {
-  heading: string;
-  body: string;
-}
-interface ComponentDocs {
-  file: string;
-  description?: string;
-  sections: DocSection[];
-  frontmatter: Record<string, string | string[]>;
-}
-interface ComponentInfo {
-  /** How the component is referenced in JSX: `Button`, `CardHeader` or `Tabs.List`. */
-  name: string;
-  /** Other names that resolve to the same component (e.g. `Card.Header` when `CardHeader` is also exported). */
-  aliases: string[];
-  description?: string;
-  deprecated?: string | true;
-  /** Suggested import specifier, e.g. `@/components/ui/button`. */
-  importPath: string;
-  /** Exported binding name, or the static member path for compound members. */
-  exportName: string;
-  source: SourceLocation;
-  /** The root component this one belongs to (`Card` for `CardHeader`). */
-  parent?: string;
-  /** Direct sub-components, in declaration order. */
-  subcomponents: string[];
-  /** Native element it renders or wraps, when it can be inferred (`button`, `input`). */
-  element?: string;
-  props: PropInfo[];
-  inherits: InheritedProps[];
-  /**
-   * True when part of the props type could not be resolved (missing
-   * `node_modules`, a type error). The linter then skips unknown-prop checks.
-   */
-  openProps: boolean;
-  variants: VariantInfo[];
-  compoundVariants: CompoundVariantInfo[];
-  examples: ExampleInfo[];
-  docs?: ComponentDocs;
-  /** Utility classes used in the component source; mapped to tokens at query time. */
-  classNames: string[];
-  /** CSS custom properties referenced in the component source. */
-  cssVars: string[];
-}
-interface DesignSystemModel {
-  version: 1;
-  root: string;
-  components: ComponentInfo[];
-  tokens: Token[];
-  /** Shared inherited prop-name lists, deduplicated across components. */
-  propSets: Record<string, string[]>;
-  /**
-   * Every value the component files export, components or not (`Icons`,
-   * `buttonVariants`), so the linter tells an invented name from a real export.
-   */
-  exports: string[];
-  /** Non-fatal problems found while extracting (unparseable files, unmatched docs). */
-  warnings: string[];
-  /**
-   * The component files extraction read, relative to the root: a name one of them exports
-   * that is not a component was seen, while a file outside them was never looked at.
-   */
-  sources?: string[];
-  stats: {
-    files: {
-      components: number;
-      tokens: number;
-      docs: number;
-    };
-    durationMs: number;
-    fromCache: boolean;
-  };
-}
-type Severity = 'error' | 'warning';
-interface TextEdit {
-  /** 0-based offsets into the checked source, end exclusive. */
-  range: [number, number];
-  text: string;
-}
-interface Diagnostic {
-  ruleId: string;
-  severity: Severity;
-  message: string;
-  /** 1-based. */
-  line: number;
-  /** 1-based. */
-  column: number;
-  endLine: number;
-  endColumn: number;
-  /** The offending source text. */
-  source: string;
-  /** What to write instead, e.g. `bg-destructive` or `<Button>`. */
-  suggestion?: string;
-  /** Edits that apply the suggestion, when it can be done mechanically. */
-  fix?: TextEdit[];
-}
-interface CheckResult {
-  file: string;
-  diagnostics: Diagnostic[];
-  errorCount: number;
-  warningCount: number;
-  /** With a baseline: findings it accepted, left out of `diagnostics` and the counts. */
-  baselined?: number;
-  /**
-   * Components imported from design-system modules the model does not include
-   * (extraction is incomplete), which the rules could not check.
-   */
-  unchecked?: {
-    names: string[];
-    modules: string[];
-  };
-  /**
-   * Why the file was not checked: it renders outside the browser's CSS (an
-   * Open Graph image through next/og, an email through React Email), where
-   * design tokens and classes do not apply.
-   */
-  skipped?: string;
-}
-//#endregion
 //#region src/lint/analyze.d.ts
 interface ImportBinding {
   source: string;
@@ -493,6 +115,12 @@ export declare function parseCssTokens(css: string, file: string): {
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/design-md.d.ts
+export declare function parseDesignMd(text: string, file: string): {
+  tokens: Token[];
+  warnings: string[];
+};
+//#endregion
 //#region src/tokens/dtcg.d.ts
 interface DtcgOptions {
   /** Prefix for generated custom property names: `ds` → `--ds-color-primary`. */
@@ -503,6 +131,34 @@ export declare function parseDtcgTokens(text: string, file: string, options?: Dt
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/export.d.ts
+/**
+ * Writes the tokens onsystem found as a DTCG 2025.10 file or a DESIGN.md. Both are grouped by
+ * category; reading the DTCG file back gives the same tokens, with the same names.
+ */
+interface Exported {
+  text: string;
+  /** How many tokens were written. */
+  count: number;
+  /** Tokens left out, and why. */
+  warnings: string[];
+}
+/**
+ * The tokens as a DTCG 2025.10 file: a group per category, colors as color objects in their
+ * own color space, lengths as `{ value, unit }`, aliases as references, and what DTCG has no
+ * field for (the token's name, the custom property, the Tailwind theme variable, dark and
+ * other modes) under `$extensions["com.github.dgesteves.onsystem"]`.
+ */
+export declare function toDtcg(tokens: readonly Token[]): Exported;
+/**
+ * The tokens as a DESIGN.md: front matter with the colors, typography, rounded corners and
+ * spacing in the spec's schema, then a heading per category with a table of its tokens, their
+ * values in each mode and how code uses them.
+ */
+export declare function toDesignMd(tokens: readonly Token[], options: {
+  name: string;
+}): Exported;
+//#endregion
 //#region src/tokens/index.d.ts
 interface TokenSource {
   file: string;
@@ -639,6 +295,8 @@ declare class LintTarget {
   private readonly moduleDirs;
   /** The files extraction read, when the model says. */
   private readonly sources?;
+  /** Published libraries the model read from type declarations: `@mui/material`. */
+  readonly libraries: Set<string>;
   /**
    * `resolver` finds the module an import points at and what it exports
    * (`@calcom/ui/components/icon` → `components/icon/index.ts`), so a name from
@@ -694,6 +352,10 @@ declare class LintTarget {
   /** The component a module exports as `default`, for `import Anything from "..."`. */
   defaultExport(specifier: string, fromFile?: string): ComponentInfo | undefined;
   private resolveRelative;
+  /** The library an import specifier points into (`@mui/material/Button`), if any. */
+  libraryOf(specifier: string): string | undefined;
+  /** The library's own component of that name: `Button` from `@mui/material`, not a wrapper. */
+  libraryComponent(name: string, library: string): ComponentInfo | undefined;
   /** Component names for "did you mean" suggestions. */
   names(): string[];
 }
@@ -760,13 +422,18 @@ type Resolution =
   kind: 'external';
 };
 //#endregion
+//#region src/lint/rules/index.d.ts
+/** Every rule, in the order they run. */
+export declare const RULES: readonly Rule[];
+//#endregion
 //#region src/lint/format.d.ts
-type OutputFormat = 'pretty' | 'json' | 'github';
+type OutputFormat = 'pretty' | 'json' | 'github' | 'sarif';
 /**
  * Renders check results:
  * - `pretty`: grouped by file, for terminals and agents,
  * - `json`: the raw results,
- * - `github`: workflow commands that GitHub Actions turns into PR annotations.
+ * - `github`: workflow commands that GitHub Actions turns into PR annotations,
+ * - `sarif`: a SARIF 2.1.0 log, for GitHub code scanning and other SARIF consumers.
  */
 export declare function formatDiagnostics(results: CheckResult[], format: OutputFormat, options?: {
   color?: boolean;
@@ -776,10 +443,14 @@ export declare function formatDiagnostics(results: CheckResult[], format: Output
   fixedHint?: string | undefined;
   /** What the run left out: `5 design-system files skipped`, `12 tests and stories left out`. */
   notes?: readonly string[] | undefined;
+  /**
+   * `sarif` and `github`: a result's file as a path relative to the repository root, which
+   * code scanning and workflow commands resolve locations against.
+   */
+  uri?: ((file: string) => string) | undefined;
 }): string;
 //#endregion
 //#region src/lint/index.d.ts
-export declare const RULES: readonly Rule[];
 interface CheckOptions {
   /** File name used in results and to pick TSX vs JSX parsing. Default `snippet.tsx`. */
   filename?: string | undefined;
@@ -849,6 +520,12 @@ export declare class DesignSystem {
   readonly config: ResolvedConfig;
   readonly lint: LintTarget;
   private readonly searchIndex;
+  /**
+   * The components the tools offer: all of them, except a library's (MUI's) where the project
+   * has its own of that name, a wrapper the team means to be used. The rules still check code
+   * that imports the library's directly against the library's.
+   */
+  private readonly offered;
   constructor(model: DesignSystemModel, config: ResolvedConfig);
   get root(): string;
   get components(): ComponentInfo[];
@@ -867,6 +544,14 @@ export declare class DesignSystem {
   }): Token[];
   /** Tokens a component's classes and CSS variables reference, e.g. `bg-primary` → `primary`. */
   relatedTokens(component: ComponentInfo): Token[];
+  /**
+   * Whether `check --require-design-system` (and the GitHub Action, where it is on by default)
+   * finds a design system to check against: components and color tokens, or components from a
+   * published library (MUI). A library is the design system whatever its theme: when the theme's
+   * colors cannot be read (a palette from Sass variables), the check still runs and `notice()`
+   * says that no-hardcoded-color did not.
+   */
+  hasDesignSystem(): boolean;
   /**
    * What the rules could not check, when it matters: without components the
    * component rules find nothing, and without color tokens neither does
@@ -1086,14 +771,17 @@ declare class Catalog {
 //#region src/server/index.d.ts
 export declare const INSTRUCTIONS = "This server describes the project's design system: its React components (props, variants, parts), design tokens and usage docs, and lints UI code against it.\nWhen writing or changing UI in this project:\n1. Find components with search_components (by intent) or list_components.\n2. Read get_component before using a component: use only the props and variant values it lists.\n3. Style with tokens from get_tokens, never with hex/rgb colors, arbitrary px values or Tailwind's default palette.\n4. Run check_ui on every snippet or file you write and fix all errors before you finish.\nIn a monorepo served from its root, pass `path` (the file you are editing) to list_components, get_component, search_components and get_tokens, and `path` or `filename` to check_ui, so each answer comes from that file's own project.";
 interface CreateServerOptions {
-  /** Resolves the design system to serve. Called per request, so it can be swapped on reload. */
-  getDesignSystem: () => Promise<DesignSystem>;
+  /**
+   * Resolves the design system to serve. Called per request, so it can be swapped on reload.
+   * `target` is the `path` (or `filename`) the request names, if any, as given.
+   */
+  getDesignSystem: (target?: string) => Promise<DesignSystem>;
   /**
    * At a workspace root: its projects. When this resolves to a set, the tools take a `path`
    * to pick a project and serve every project together without one, and `getDesignSystem`
-   * is not called.
+   * is not called. `target` is the `path` (or `filename`) the request names, if any.
    */
-  getProjects?: () => Promise<ProjectSet | undefined>;
+  getProjects?: (target?: string) => Promise<ProjectSet | undefined>;
 }
 /** Builds the MCP server: five tools, two resources and one prompt. Transport-agnostic. */
 export declare function createServer({ getDesignSystem, getProjects }: CreateServerOptions): McpServer;
@@ -1123,10 +811,19 @@ interface ServerHandle {
  * deprecates, are the fallback for a 2025-era client that starts servers somewhere
  * else (Claude Desktop starts them in `/`): its first `file://` root. At a monorepo
  * root with no design system of its own, every project in it is served.
+ *
+ * When none of those gives a project (a client that starts servers in the home or the
+ * plugin's folder and reports no roots), each request's project is found from the
+ * absolute path it names (`findProjectRoot`): the nearest folder at or above it with a
+ * project marker, or the monorepo root above that, served as if the server had been
+ * started there, except that a config there is read only when it is JSON: a prompt can
+ * choose the path, so a JavaScript or TypeScript config is not run. Each root found is
+ * loaded once and kept; a request without an absolute path is answered from the one root
+ * found so far.
  */
 export declare function serveStdio(options: ServeOptions): Promise<ServerHandle>;
 //#endregion
 //#region src/version.d.ts
 export declare const VERSION: string;
 //#endregion
-export type { CheckResult, ComponentDocs, ComponentInfo, CompoundVariantInfo, Config, DesignSystemModel, Diagnostic, DocSection, ExampleInfo, HostOptions, InheritedProps, LoadConfigOptions, LoadOptions, OutputFormat, PropInfo, ResolvedConfig, RuleId, Severity, SourceLocation, TOKEN_CATEGORIES, TextEdit, Token, TokenCategory, VariantInfo };
+export { type CheckResult, type ComponentDocs, type ComponentInfo, type CompoundVariantInfo, type Config, type DesignSystemModel, type Diagnostic, type DocSection, type ExampleInfo, type HostOptions, type InheritedProps, type LoadConfigOptions, type LoadOptions, type OutputFormat, type PropInfo, RULE_IDS, type ResolvedConfig, type RuleId, type Severity, type SourceLocation, type TOKEN_CATEGORIES, type TextEdit, type Token, type TokenCategory, type VariantInfo, configJsonSchema, defineConfig, loadConfig };

package/dist/index.js

@@ -1,2 +1,3 @@
-import { B as loadConfig, C as loadTokens, D as attachDocs, E as parseCssTokens, H as findVariantDefinitions, L as RULE_IDS, O as parseDoc, R as configJsonSchema, S as TokenIndex, T as parseDtcgTokens, _ as RULES, a as DesignSystem, g as searchComponents, i as createServer, k as extractComponents, l as fingerprint, o as DesignSystemHost, p as VERSION, r as INSTRUCTIONS, s as buildModel, t as serveStdio, u as loadDesignSystem, v as applyFixes, w as mergeTokens, x as formatDiagnostics, y as checkSource, z as defineConfig } from "./stdio-BcJth14k.js";
-export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDoc, parseDtcgTokens, searchComponents, serveStdio };
+import { $ as findVariantDefinitions, A as toDtcg, D as loadTokens, E as TokenIndex, F as attachDocs, G as RULE_IDS, I as parseDoc, K as configJsonSchema, L as extractComponents, M as parseDtcgTokens, N as parseDesignMd, O as mergeTokens, P as parseCssTokens, T as RULES, Y as loadConfig, _ as VERSION, a as fingerprint, d as searchComponents, f as applyFixes, h as formatDiagnostics, k as toDesignMd, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, q as defineConfig, r as buildModel, t as DesignSystem } from "./design-system-A3pRX3Ka.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-CEChNFLR.js";
+export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDesignMd, parseDoc, parseDtcgTokens, searchComponents, serveStdio, toDesignMd, toDtcg };