rainbowindex 0.5.1 → 0.7.0

package/dist/editor.d.ts

@@ -1,40 +1,10 @@
-import { P as ParsedDirective, R as ResolvedTheme } from './index-Dx-NpFFx.js';
-export { b as createThemeSnapshot } from './index-Dx-NpFFx.js';
-import { b as CompilationSnapshot, C as ColorDefinition } from './context-B9yhJxd5.js';
-export { e as defaultTheme } from './context-B9yhJxd5.js';
-
-/** Where a candidate was found. "expression" marks a string literal sitting
- *  in a JS expression position that cannot be a class list — today, an
- *  operand of `==`/`!=` (`mode === "default"`). It is NOT a certain origin:
- *  editors should treat it like "plain" and never report it as a bad class. */
-type CandidateOrigin = "attribute" | "helper" | "safelist" | "plain" | "expression";
-interface ClassCandidate {
-    /** The class string in expanded form — for variant-group members this
-     *  includes the group prefix (`hover:bg-red-500`) even though the span
-     *  covers only the member token inside the braces. */
-    value: string;
-    /** Absolute [start, end) span of the visible token in the original source.
-     *  `source.slice(start, end)` is the member token for group members and
-     *  `value` itself everywhere else. */
-    start: number;
-    end: number;
-    origin: CandidateOrigin;
-    /** The call the class was found in, when origin is "helper"/"safelist". */
-    helperName?: string;
-    /** Identity of the innermost scanned helper/safelist call context:
-     *  candidates from the same call share one id, distinct calls get distinct
-     *  ids. A class helper nested inside another class helper's arguments is
-     *  not scanned as its own call — its literals belong to the outer call —
-     *  while a class helper inside a cva/tv config does get its own id. Ids
-     *  are only comparable within one extraction's result. Absent for
-     *  attribute/plain candidates. */
-    callId?: number;
-    /** For variant-group members: span of the group's variant prefix (`hover:`). */
-    groupPrefix?: {
-        start: number;
-        end: number;
-    };
-}
+import { C as ClassCandidate, D as Diagnostic } from './session-CMaskdB7.js';
+export { a as CANONICAL_COLOR_STOPS, b as CandidateOrigin, c as ClassEnumeration, d as ClassExplanation, e as ClassInspector, f as ClassTemplate, g as ClassValidation, h as ColorSwatch, i as DiagnosticSeverity, E as EditorSession, j as EnumeratedClass, M as MergeAnalysis, k as MergeDrop, P as ParsedUtility, R as RenderStylesheetOptions, l as RenderedStylesheet, S as SwatchColor, T as ThemeTokens, U as UTILITY_VALUE_SPACES, V as ValueSpaceKind, m as ValueSpaceSpec, n as VariantInfo, o as VariantKind, p as analyzeMerge, q as createClassInspector, r as createEditorSession, s as cssColorToHex, t as diagnosticFromWarning, u as enumerateClassNames, v as listThemeTokens, w as listVariants, x as oklchToHex, y as parseUtility, z as renderStylesheet, A as resolveColorSwatch, B as severityForCode, F as warningCode } from './session-CMaskdB7.js';
+import { P as ParsedDirective, R as ResolvedTheme } from './imports-C9esHd5Q.js';
+export { a as ImportResolution, I as ImportResolver, b as InlineImportsOptions, c as InlineImportsResult, d as describeLoadedWeights, i as inlineDirectiveImports, w as weightIsLoaded } from './imports-C9esHd5Q.js';
+export { C as ColorDefinition, d as defaultTheme } from './index-Czx-EUwh.js';
+export { a as CompilationSnapshot, S as SerializedSnapshot, h as hydrateSnapshot, p as publishSnapshot, s as serializeSnapshot } from './context-DcBtnnan.js';
+export { b as createThemeSnapshot } from './index-DW8YSxTz.js';
 
 /** Helper-call names whose string arguments are walked for class literals.
  *  Exported for editor tooling so completion-context detection can match the
@@ -44,7 +14,7 @@ declare const CLASS_HELPER_NAMES: readonly string[];
 declare const VARIANT_HELPER_NAMES: readonly string[];
 declare function extractClasses(source: string, warnings?: string[]): Set<string>;
 
-declare function expandVariantGroups(input: string, warnings?: string[]): string;
+declare function expandVariantGroups(input: string, warnings?: string[], path?: string): string;
 
 interface SourceExtractionInput {
     path?: string;
@@ -69,6 +39,42 @@ declare function extractClassCandidates(input: SourceExtractionInput, warnings?:
  */
 declare function isSourceFile(file: string): boolean;
 
+/**
+ * `outermostCandidates` — the candidates that correspond to what was typed.
+ *
+ * The scanner over-collects on purpose. It is a lexer, not a parser, and a
+ * class it invents costs nothing: an unknown utility compiles to no rule. So
+ * in JavaScript, where `:` is also a ternary and an object key, it emits both
+ * the joined token and the fragments around each colon —
+ * `sm:hover:focus:flex` arrives as four candidates, three of whose spans sit
+ * inside the fourth. The HTML extractor, which has no such ambiguity, emits
+ * one.
+ *
+ * For a build that asymmetry is invisible. For anything that maps a candidate
+ * back to a *place in the source* — an underline, a quick fix, a hover — it is
+ * a defect: an editor would report `sm` in `sm:flex` as an unknown class,
+ * which is both wrong and impossible to act on. This is the filter that turns
+ * the scanner's candidate stream into one entry per class the author wrote.
+ *
+ * Kept out of the scanner deliberately. The extra candidates are the
+ * over-collection working as designed, and the compile path is entitled to
+ * them; it is the editor path that wants one candidate per class.
+ */
+
+/**
+ * Drop every candidate whose source span lies inside another candidate's span.
+ *
+ * A candidate is dropped when some other span strictly contains it — another
+ * candidate's own span, or the `groupPrefix` span a variant-group member
+ * points back at, which is what covers the stray `hover` in
+ * `hover:{px-2 py-1}`. Two candidates over the identical span keep the first
+ * in input order. Everything kept is returned in source order.
+ *
+ * Origins are untouched: filter to `attribute` / `helper` / `safelist` first
+ * if prose and bare identifiers are not wanted either.
+ */
+declare function outermostCandidates(candidates: readonly ClassCandidate[]): ClassCandidate[];
+
 /**
  * Default CSS entry candidates — the paths the CLI, the Vite plugin, and
  * editor tooling probe (in order) when locating the project's Rainbow Index
@@ -79,7 +85,13 @@ declare function isSourceFile(file: string): boolean;
 declare const CSS_ENTRY_CANDIDATES: readonly string[];
 
 /** Import specifiers that activate RainbowIndex. Single source for the
- *  activation scan here, the PostCSS import matcher, and the strip regex. */
+ *  activation scan here, the PostCSS import matcher, and the strip regex.
+ *
+ *  The preset is on the list because a stylesheet whose only Rainbow Index
+ *  content is `@import "rainbowindex/tailwind.css"` is unmistakably asking to
+ *  be compiled. It is deliberately *not* in the marker list above: unlike the
+ *  two markers it is a real stylesheet full of directives, and the inliner has
+ *  to resolve and read it like any other package preset. */
 declare const RI_IMPORT_SPECIFIERS: readonly string[];
 /**
  * Detect whether source activates RainbowIndex: any RI directive token
@@ -88,39 +100,6 @@ declare const RI_IMPORT_SPECIFIERS: readonly string[];
  */
 declare function hasRIActivation(src: string): boolean;
 
-/**
- * Structured diagnostics — the typed view of the `[RI-NNNN] message` warning
- * strings, for editor tooling that anchors problems to source spans.
- *
- * The legacy string arrays stay the wire format everywhere (and the warning
- * budget/dedup in warnings.ts keeps operating on them); a Diagnostic carries
- * the same full message text verbatim, plus the parsed code, a severity
- * derived from the documented code-range convention, and — when the emission
- * site knew one — a [start, end) span into the CSS input. Consumers can rely
- * on `diagnostics[i].message === warnings[i]` wherever both are returned.
- */
-type DiagnosticSeverity = "error" | "warning";
-interface Diagnostic {
-    /** The RI-NNNN code, or null when the message carries no parseable code. */
-    code: string | null;
-    severity: DiagnosticSeverity;
-    /** The full legacy warning text, including the `[RI-NNNN]` prefix. */
-    message: string;
-    /** [start, end) span in the analyzed CSS input, or null when unknown. */
-    start: number | null;
-    end: number | null;
-}
-/** Extract the RI-NNNN code from a legacy warning string, or null. */
-declare function warningCode(message: string): string | null;
-/**
- * Severity by code range — the same convention warnings.ts budgets by:
- * RI-0xxx (fatal/bootstrap) and RI-2xxx (compile/runtime errors) are errors,
- * everything else (informational 1xxx ranges) is a warning.
- */
-declare function severityForCode(code: string | null): DiagnosticSeverity;
-/** Wrap a legacy warning string as a Diagnostic, with an optional span. */
-declare function diagnosticFromWarning(message: string, span?: readonly [number, number] | null): Diagnostic;
-
 /**
  * Theme-only project analysis — the cheap front half of compileProject.
  *
@@ -144,140 +123,22 @@ interface ProjectAnalysis {
      * at-rule, resolver problems at the directive whose body produced them.
      */
     diagnostics: Diagnostic[];
-}
-declare function analyzeProjectCSS(css: string): ProjectAnalysis;
-
-/**
- * Parses utility class strings into structured tokens.
- *
- * "hover:bg-red-500"  → { variants: ["hover"], utility: "bg", value: "red-500" }
- * "sm:p-4"            → { variants: ["sm"], utility: "p", value: "4" }
- * "text-center!"      → { variants: [], utility: "text-center", value: null, important: true }
- * "p-[13px]"          → { variants: [], utility: "p", value: "[13px]", arbitrary: true }
- * "@md:flex"           → { variants: ["@md"], utility: "flex", value: null }
- * "pl-physical-4"     → { variants: [], utility: "pl", value: "4", physical: true }
- */
-interface ParsedUtility {
-    /** Original class string before parsing */
-    raw: string;
-    /** Variant prefixes in order, e.g. ["hover"], ["sm", "hover"] */
-    variants: string[];
-    /** The utility name (everything before the value separator), e.g. "bg", "p", "text" */
-    utility: string;
-    /** The value part after the last `-`, or null for valueless utilities like "flex" */
-    value: string | null;
-    /** Whether the value is an arbitrary bracket expression like [13px] */
-    arbitrary: boolean;
-    /** Whether !important is applied */
-    important: boolean;
-    /** Whether the -physical- infix is present */
-    physical: boolean;
-    /** Whether the utility is negative (prefixed with -) */
-    negative: boolean;
-    /** When the class is an arbitrary property like [color:red] */
-    arbitraryProperty: {
-        property: string;
-        value: string;
-    } | null;
     /**
-     * Explicit type hint extracted from an arbitrary value, e.g. the `length`
-     * in `border-[length:1rem]` or `border-(color:--my-color)`. When set, it
-     * forces a specific dispatch path in generators — see `borderGenerator`,
-     * `colorGenerator`, etc. Null when no hint was provided.
+     * Codes silenced for the whole entry by `/* ri-disable … *\/`. Later stages
+     * push through this so a code the author hid never reaches the caller —
+     * scanner and compile warnings included, which no stylesheet comment could
+     * reach by position.
      */
-    dataType: string | null;
-}
-/**
- * Parse a single utility class string into its structural components.
- */
-declare function parseUtility(raw: string): ParsedUtility;
-
-/**
- * Shared leaf helpers for the utility generators — result types, tiny
- * constructors, and value-grammar helpers. Lives below both the generators
- * and the dispatch index (which imports every generator) so that generators
- * never import their own aggregator: generator ↔ index cycles would let
- * modules observe partially initialized exports.
- */
-interface CSSDeclaration {
-    property: string;
-    value: string;
-}
-
-/**
- * Variant resolution — maps variant names to CSS wrappers.
- *
- * Handles pseudo-classes, pseudo-elements, media queries, responsive breakpoints,
- * container queries, data/aria attributes, :has()/:not(), arbitrary variants,
- * and custom variants.
- */
-
-type VariantKind = "pseudo-class" | "pseudo-element" | "media" | "breakpoint" | "container" | "special" | "custom" | "pattern";
-interface VariantInfo {
-    /** The variant as typed before the `:` — for patterns, the family prefix. */
-    name: string;
-    kind: VariantKind;
-    /** What the variant emits — a selector suffix, an at-rule, or (for
-     *  patterns) a description of the accepted form. */
-    wraps: string;
+    suppressed: ReadonlySet<string>;
 }
-/**
- * Enumerate every concrete variant the given theme resolves, plus the
- * open-ended pattern families. Concrete entries (kind ≠ "pattern") are
- * guaranteed to resolve via resolveVariant — the list mirrors its checks,
- * including the CSS-length guard on breakpoint values.
- */
-declare function listVariants(theme: ResolvedTheme): VariantInfo[];
+declare function analyzeProjectCSS(css: string): ProjectAnalysis;
 
 /**
- * Class inspector — single-class validation and explanation for editor
- * tooling, running the exact resolution the compile loop performs.
- *
- * The compiler intentionally drops unknown utilities silently (reserved
- * RI-1001): the build scanner over-collects, so at build time an unresolved
- * candidate is usually noise. Inside an editor the certainty is inverted — a
- * token in a class attribute is meant to be a class — so the inspector
- * finally gives RI-1001 a voice: `validate()` reports WHY a class produces no
- * CSS, with a typo suggestion when one is close enough.
- *
- * An inspector instance owns the per-theme caches the compile loop rebuilds
- * per pass (custom-variant map, variant memo, breakpoint weights) plus a
- * resolution cache, so per-keystroke validation of the same classes is cheap.
- * Create one per theme and drop it when the theme changes.
+ * Fatal bootstrap (RI-00xx) and runtime (RI-20xx) codes are never silenceable.
+ * They report a broken build or a broken call, not a style choice, and a
+ * stylesheet that could hide them would hide the reason the build failed.
  */
-
-type ClassValidation = {
-    ok: true;
-} | {
-    ok: false;
-    reason: "unknown-utility" | "unknown-variant" | "invalid-arbitrary";
-    /** The failing fragment — the variant for "unknown-variant", the
-     *  base class (variants stripped) otherwise. */
-    offender: string;
-    /** Closest known name within typo distance, when one exists. */
-    suggestion?: string;
-};
-interface ClassExplanation {
-    parsed: ParsedUtility;
-    /** Root declarations before variant wrapping. */
-    declarations: CSSDeclaration[];
-    /** Escaped selector, including variant suffixes (`.hover\:px-2:hover`). */
-    selector: string;
-    /** The complete rule text, including wrapping at-rules. */
-    css: string;
-    /** Deterministic ordering key — lower emits earlier in generated CSS. */
-    sortKey: number;
-}
-interface ClassInspector {
-    readonly theme: ResolvedTheme;
-    /** Would this class produce CSS under the theme? Reports why not. */
-    validate(className: string): ClassValidation;
-    /** Structured breakdown + generated CSS, or null when invalid. */
-    explain(className: string): ClassExplanation | null;
-    /** Every variant the theme resolves (cached). */
-    variants(): readonly VariantInfo[];
-}
-declare function createClassInspector(theme: ResolvedTheme): ClassInspector;
+declare function isSuppressible(code: string): boolean;
 
 /**
  * Typo suggestion helpers using optimal string alignment (OSA) distance —
@@ -290,236 +151,36 @@ declare function createClassInspector(theme: ResolvedTheme): ClassInspector;
  */
 declare function findClosest(input: string, candidates: string[], maxDistance?: number): string | null;
 
-/**
- * The single registration table for built-in utility roots: each row binds a
- * set of roots to the generators that resolve them (in probe order) AND to the
- * value space editor enumeration tries for them. index.ts derives
- * PREFIX_DISPATCH from the resolver columns; enumerate.ts derives
- * UTILITY_VALUE_SPACES from the spec column — adding a root forces deciding
- * both in one row, so the two can never drift.
- *
- * Value spaces are deliberately GENEROUS (which theme namespaces and keyword
- * families to TRY per functional root): every enumeration candidate is probed
- * through the real utility resolver, which stays the single authority — a
- * spec can over-approximate freely and never emit something `validate()`
- * would reject. `{ kinds: [] }` marks a statics-only root.
- *
- * Ordering is load-bearing twice over: row order fixes PREFIX_DISPATCH key
- * insertion order (which drives cross-root enumeration dedup labels), and
- * per-root resolver order fixes which generator wins a contested root.
- */
-
-type ValueSpaceKind = "color" | "special-color" | "spacing" | "fraction" | "text-size" | "fluid-text-size" | "font-slot" | "weight" | "rounded" | "rounded-side" | "shadow" | "z" | "ease" | "blur" | "animation" | "leading" | "tracking" | "opacity" | "duration" | "breakpoint" | "int" | "percent" | "keywords";
-interface ValueSpaceSpec {
-    kinds: readonly ValueSpaceKind[];
-    /** Extra value parts to try verbatim (for "keywords" and beyond). */
-    keywords?: readonly string[];
-}
-
-/**
- * Class enumeration — the completion universe for editor tooling.
- *
- * Design: candidates are generated from a deliberately GENEROUS value-space
- * table (which theme namespaces and keyword families to TRY per functional
- * root), then every candidate is probed through the real utility resolver.
- * The resolver is the single authority — an enumerated class is one that
- * actually compiles, so the table can over-approximate freely and can never
- * emit something `validate()` would reject. Coverage is structural: the table
- * derives from ROOT_GROUPS (roots.ts), where `spec` is a required field of
- * every row — adding a root forces deciding its value space in the same row
- * (an empty spec marks a statics-only root); the CI check in enumerate.test.ts
- * stays on as a regression tripwire.
- *
- * Statics come from the merge conflict tables (STATIC_UTILITIES) plus each
- * generator's own static-map keys — probed too, for the same guarantee.
- */
-
-/** Root → value spaces to try, derived from ROOT_GROUPS. Every
- *  PREFIX_DISPATCH root is present by construction — both maps are built
- *  from the same rows. */
-declare const UTILITY_VALUE_SPACES: ReadonlyMap<string, ValueSpaceSpec>;
-interface EnumeratedClass {
-    name: string;
-    /** How the class was produced: a static table, a custom @utility, or the
-     *  value-space kind that filled the functional root. */
-    kind: ValueSpaceKind | "static" | "custom";
-    /** The functional root, or null for statics/custom statics. */
-    root: string | null;
-}
-interface ClassTemplate {
-    root: string;
-    /** The open-ended space: numeric spacing scale, plain numbers, or a
-     *  functional custom utility that accepts any suffix. */
-    kind: "spacing" | "number" | "custom";
-    example: string;
-}
-interface ClassEnumeration {
-    /** Every finite concrete class, probed valid, sorted by name. */
-    classes: EnumeratedClass[];
-    /** Families whose value space is infinite — offer as snippets. */
-    templates: ClassTemplate[];
-}
-/**
- * Enumerate the finite completion universe for a theme. Every returned class
- * has been resolved by the real utility resolver — `validate()` accepts each
- * one by construction. Infinite families (the spacing scale, numeric values,
- * functional custom utilities) come back as templates; a template is emitted
- * only when at least one of its probes resolved.
- */
-declare function enumerateClassNames(theme: ResolvedTheme): ClassEnumeration;
-
-/**
- * analyzeMerge() — editor-only merge diagnostics.
- *
- * Explains ri()'s right-most-wins conflict resolution by threading a
- * MergeTrace through the shared merge loop. Split from merge/index.ts so the
- * browser-facing runtime file stays free of editor-only analysis; consumed by
- * editor/session.ts and the editor entry.
- */
+declare function stripRIDirectives(css: string): string;
 
-interface MergeDrop {
-    index: number;
-    className: string;
-    /** Ascending indices of the surviving classes that together claimed every
-     *  CSS property this class sets (px-4 + py-4 jointly dominate p-2). */
-    overriddenBy: number[];
-}
-interface MergeAnalysis {
-    /** The merged output — identical to ri()'s result for this token list. */
-    output: string;
-    /** Indices of surviving classes, ascending. */
-    kept: number[];
-    /** Dropped classes with attribution, ascending by index. */
-    dropped: MergeDrop[];
-}
 /**
- * Explain ri()'s conflict resolution for a list of class tokens — which
- * classes the right-most-wins scan drops, and which survivors claimed their
- * properties. Powers "this class is overridden" editor diagnostics.
+ * One sort, for everything that orders class names.
  *
- * Unlike ri(), the input is pre-tokenized: one class per element, no falsy
- * filtering, no whitespace splitting — exactly the token list an editor
- * extracts from one class attribute. `snapshot` binds custom utilities, text
- * sizes, and color names the same way createRi(snapshot) does (editors build
- * one with createThemeSnapshot()); without it, the module-level state of the
- * most recent compile applies. Uncached — call sites own their memoization.
- */
-declare function analyzeMerge(classes: readonly string[], snapshot?: CompilationSnapshot): MergeAnalysis;
-
-/**
- * Color swatches and theme-token introspection for editor tooling.
+ * A "sort classes" command in an editor, a formatter plugin, and a CLI
+ * codemod all have to agree, and the only way to guarantee that is for all
+ * three to call the same function. The order is the one the emitted CSS uses:
+ * `sortKey` first, then the same codepoint tie-break `compile()` applies to
+ * rules, so reading a sorted class attribute tells you what the cascade will
+ * do — including which of two conflicting classes actually wins.
  *
- * Resolves a theme color (and stop) to concrete light/dark colors — the same
- * OKLCH math the CSS variable emitter uses (generateStop / computeDarkStop),
- * plus an sRGB hex conversion for completion-item swatches and sidebar chips.
- * Pure computation, no IO.
- */
-
-/** The canonical palette stops every generative color defines. */
-declare const CANONICAL_COLOR_STOPS: readonly number[];
-/** Convert an OKLCH color to a #rrggbb hex string (sRGB, channel-clamped). */
-declare function oklchToHex(l: number, c: number, h: number): string;
-/** Best-effort hex for the CSS color texts theme definitions hold: `oklch()`
- *  and hex literals. Anything else (named colors, rgb(), vars) returns null —
- *  the raw CSS text still travels alongside. */
-declare function cssColorToHex(css: string): string | null;
-interface SwatchColor {
-    /** CSS color text (`oklch(…)`, or the definition's own value verbatim). */
-    css: string;
-    /** sRGB hex, or null when the CSS text isn't convertible. */
-    hex: string | null;
-}
-interface ColorSwatch {
-    light: SwatchColor;
-    /** Null when the theme's dark mode is off or the color has no dark form. */
-    dark: SwatchColor | null;
-}
-/**
- * Resolve a theme color name (+ stop, for generative palettes) to concrete
- * light/dark swatch colors — exactly the values the emitted CSS variables
- * carry. Theme-defined colors always win; the fixed semantic swatches
- * (paper/ink/white/black) apply only when the theme does not define the name,
- * mirroring the emitter (a user `@color { white: … }` palette emits
- * `--color-white-*` variables that suffixed utilities resolve against).
- * Returns null for unknown names, unresolvable aliases, and keyword colors
- * with no concrete value (transparent, currentColor).
+ * **A class list that reaches `ri()` must not be sorted.** `ri()` is
+ * right-most-wins over its arguments, so reordering changes the result. This
+ * is for a static class attribute, where the CSS decides and the attribute's
+ * order carries no meaning at all.
  */
-declare function resolveColorSwatch(theme: ResolvedTheme, name: string, stop?: number): ColorSwatch | null;
-interface ThemeTokens {
-    /** Color names with their definition kind — pair with resolveColorSwatch. */
-    colors: Array<{
-        name: string;
-        kind: ColorDefinition["type"];
-    }>;
-    colorStops: readonly number[];
-    spacingBase: string;
-    textSizes: Array<{
-        name: string;
-        fontSize: string;
-        lineHeight: string;
-    }>;
-    breakpoints: Record<string, string>;
-    shadows: Record<string, string>;
-    weights: Record<string, number>;
-    easing: Record<string, string>;
-    blur: Record<string, string>;
-    z: Record<string, string>;
-    leading: Record<string, string>;
-    tracking: Record<string, string>;
-    opacity: Record<string, string>;
-    duration: Record<string, string>;
-    fonts: Array<{
-        slot: string;
-        family: string;
-    }>;
-    animations: string[];
-}
-/** One render-ready view of a theme's token namespaces for sidebar chips and
- *  completion detail — plain data, no theme internals to traverse. */
-declare function listThemeTokens(theme: ResolvedTheme): ThemeTokens;
 
 /**
- * Editor session — the façade that ties the editor toolkit together.
+ * Order `classes` the way the generated stylesheet orders their rules.
  *
- * An editor host holds one session per workspace, calls `setCss()` whenever
- * the project's CSS entry changes, and everything else per keystroke. The
- * session owns the caching story: theme analysis, the class inspector, the
- * enumeration, token introspection, and the merge snapshot are computed
- * lazily and invalidated together when the CSS changes — callers never
- * juggle per-theme cache keys themselves. Every capability is also exported
- * à la carte from `rainbowindex/editor` for hosts that want finer control.
+ * Unresolvable classes come first, in their original order; everything else
+ * follows in emission order. Duplicates are kept — dropping a class silently
+ * is never the right answer for a formatter — and the result is a new array.
  *
- * Pure computation, no IO: the host reads the CSS file (see
- * CSS_ENTRY_CANDIDATES / hasRIActivation for locating it) and passes text.
+ * Variant groups (`hover:{underline font-bold}`) are one token here, and one
+ * token is all a sort can move. Expand them with `expandVariantGroups` first
+ * if the members should be ordered individually.
  */
-
-interface EditorSession {
-    /** The CSS input the session is currently analyzing. */
-    readonly css: string;
-    /** Swap the CSS input; all theme-derived caches invalidate together.
-     *  A no-op when the text is unchanged. */
-    setCss(css: string): void;
-    readonly theme: ResolvedTheme;
-    /** Positioned diagnostics for the CSS input (see ProjectAnalysis). */
-    readonly diagnostics: readonly Diagnostic[];
-    /** Single-class validation/explanation, cached per theme. */
-    readonly inspector: ClassInspector;
-    /** The finite completion universe + templates, cached per theme. */
-    enumerate(): ClassEnumeration;
-    /** Render-ready token namespaces, cached per theme. */
-    tokens(): ThemeTokens;
-    /** The merge snapshot for this theme, cached. */
-    snapshot(): CompilationSnapshot;
-    /** analyzeMerge bound to this theme's snapshot. */
-    analyzeMerge(classes: readonly string[]): MergeAnalysis;
-    /** Position-aware class extraction for a source document. */
-    extractCandidates(content: string, path?: string): ClassCandidate[];
-    /** Light/dark swatch for a theme color (+ stop), or null. */
-    swatch(name: string, stop?: number): ColorSwatch | null;
-}
-declare function createEditorSession(options?: {
-    css?: string;
-}): EditorSession;
+declare function sortClasses(theme: ResolvedTheme, classes: readonly string[]): string[];
 
 /**
  * `rainbowindex/editor` — the IO-free toolkit editor integrations build on.
@@ -542,4 +203,4 @@ declare const EDITOR_API_VERSION = 1;
 /** Feature-detection roster for this entry. */
 declare const editorCapabilities: readonly string[];
 
-export { CANONICAL_COLOR_STOPS, CLASS_HELPER_NAMES, CSS_ENTRY_CANDIDATES, type CandidateOrigin, type ClassCandidate, type ClassEnumeration, type ClassExplanation, type ClassInspector, type ClassTemplate, type ClassValidation, ColorDefinition, type ColorSwatch, CompilationSnapshot, type Diagnostic, type DiagnosticSeverity, EDITOR_API_VERSION, type EditorSession, type EnumeratedClass, type MergeAnalysis, type MergeDrop, ParsedDirective, type ParsedUtility, type ProjectAnalysis, RI_IMPORT_SPECIFIERS, ResolvedTheme, type SourceExtractionInput, type SwatchColor, type ThemeTokens, UTILITY_VALUE_SPACES, VARIANT_HELPER_NAMES, type ValueSpaceKind, type ValueSpaceSpec, type VariantInfo, type VariantKind, analyzeMerge, analyzeProjectCSS, createClassInspector, createEditorSession, cssColorToHex, diagnosticFromWarning, editorCapabilities, enumerateClassNames, expandVariantGroups, extractClassCandidates, extractClasses, extractClassesFromSource, findClosest, hasRIActivation, isSourceFile, listThemeTokens, listVariants, oklchToHex, parseUtility, resolveColorSwatch, severityForCode, version, warningCode };
+export { CLASS_HELPER_NAMES, CSS_ENTRY_CANDIDATES, ClassCandidate, Diagnostic, EDITOR_API_VERSION, ParsedDirective, type ProjectAnalysis, RI_IMPORT_SPECIFIERS, ResolvedTheme, type SourceExtractionInput, VARIANT_HELPER_NAMES, analyzeProjectCSS, editorCapabilities, expandVariantGroups, extractClassCandidates, extractClasses, extractClassesFromSource, findClosest, hasRIActivation, isSourceFile, isSuppressible, outermostCandidates, sortClasses, stripRIDirectives, version };