rainbowindex 0.5.1 → 0.7.0

package/dist/{index-Dx-NpFFx.d.ts → imports-C9esHd5Q.d.ts}

@@ -1,4 +1,4 @@
-import { C as ColorDefinition, j as DarkModeConfig, k as CornerShape, A as AnimationDefinition, F as FluidConfig, b as CompilationSnapshot } from './context-B9yhJxd5.js';
+import { C as ColorDefinition, D as DarkModeConfig, b as CornerShape, A as AnimationDefinition, F as FluidConfig } from './index-Czx-EUwh.js';
 
 /** Provider discriminant for a slot, derived from its faces. */
 type FontProviderKind = "google" | "system" | "local" | "manual";
@@ -57,23 +57,21 @@ interface FontMetricsConfig {
     descent?: number;
     lineGap?: number;
 }
-
 /**
- * Font loading system — @font directive processing, @font-face generation,
- * metrics-adjusted fallbacks for zero CLS.
+ * Whether any loaded font can render `weight` — the check behind RI-1504.
+ *
+ * A slot's faces are the authority: their `weight` descriptor is exactly what
+ * the emitted @font-face (or the Google URL) asks for, so a weight outside it
+ * is a weight the browser has to synthesize.
  *
- * A slot (sans/serif/mono/custom) maps to one --font-<slot> variable and one
- * family name, but can own multiple faces — e.g. an upright + an italic file,
- * or split unicode ranges. Each FontFace emits one @font-face for local
- * providers; google/system/manual slots carry a single face.
+ * Deliberately fails open, since `font-<n>` names no family and a page can
+ * load several: no faces to check, a system/manual slot (the OS font carries
+ * every weight), or a single covering slot all count as available.
  */
-
-interface FontOutput {
-    imports: string[];
-    fontFaces: string[];
-    variables: string[];
-    warnings: string[];
-}
+declare function weightIsLoaded(weight: number, fonts: readonly FontSlot[]): boolean;
+/** Human-readable weight inventory for the RI-1504 message:
+ *  `Inter 300–900; Fira Code 400, 700`. */
+declare function describeLoadedWeights(fonts: readonly FontSlot[]): string;
 
 /**
  * Raw-extractable directive names — the single source for the DirectiveType
@@ -165,6 +163,10 @@ interface ResolvedTheme {
      * `roundedShape` is null.
      */
     readonly roundedShapeScale: number;
+    /** Named radii from `@rounded { roof: 24px; }` — each one makes the class
+     *  `rounded-<name>` and the token `--rounded-<name>`. A name that matches a
+     *  built-in radius keyword replaces it; RI-1124 warns at definition. */
+    readonly radii: Readonly<Record<string, string>>;
     readonly shadows: Readonly<Record<string, string>>;
     readonly weights: Readonly<Record<string, number>>;
     readonly easing: Readonly<Record<string, string>>;
@@ -174,6 +176,10 @@ interface ResolvedTheme {
     readonly fluid: Readonly<FluidConfig>;
     readonly textFluid?: Readonly<FluidConfig>;
     readonly spacingFluid?: Readonly<FluidConfig>;
+    /** Named viewport ranges from `@fluid <name> { min; max; }` — each one makes
+     *  the scope class `fluid-<name>` and the tokens `--fluid-<name>-{min,max}`.
+     *  Ranges carry no unit: the ramp unit is baked per family. */
+    readonly fluidRanges: Readonly<Record<string, Readonly<FluidConfig>>>;
     readonly fonts: readonly FontSlot[];
     readonly preflight: Readonly<PreflightConfig>;
     readonly customUtilities: readonly CustomUtility[];
@@ -189,76 +195,87 @@ interface ResolvedTheme {
     readonly warnings: readonly string[];
 }
 
-interface CompiledRule {
-    /** The original class name (escaped for CSS selector). */
-    selector: string;
-    /** Sort key for deterministic ordering. */
-    sortKey: number;
-    /** CSS declarations as a string block. */
-    css: string;
-}
-interface CompilationResult {
-    /** All compiled CSS rules. */
-    rules: CompiledRule[];
-    /** @keyframes blocks needed. */
-    keyframes: string[];
-    /** @property declarations needed. */
-    properties: string[];
-    /** Map of used color hue → set of used suffixes (for token pruning). */
-    usedColorStops: Map<string, Set<number>>;
-    /** Set of used text size names (for token pruning). */
-    usedTextSizes: Set<string>;
-    /** Set of used font slot names (for token pruning). */
-    usedFonts: Set<string>;
-    /** Set of used rounded value names (for token pruning). */
-    /** Set of used shadow names (for token pruning). */
-    usedShadows: Set<string>;
-    /** Set of used animation shorthand names (for token pruning). */
-    usedAnimations: Set<string>;
-    /** Warnings emitted during compilation. */
-    warnings: string[];
-}
-
 /**
- * Build a CompilationSnapshot straight from a resolved theme — no compile
- * pass, no module-level state. Editor tooling pairs this with
- * analyzeMerge()/createRi() for theme-accurate merge semantics.
- */
-declare function createThemeSnapshot(theme: ResolvedTheme): CompilationSnapshot;
-/**
- * Create an isolated compiler instance for SSR / concurrent-compilation
- * environments. Returns a `compile()` function that does NOT touch module-level
- * state, and a `createRi()` that produces a merge function bound to the
- * compilation's snapshot.
+ * `@import` inlining for the directive analyzer.
+ *
+ * The analyzer reads directives out of one CSS string. Until an import is
+ * inlined, a `@color` block living in `./tokens.css` — or in a preset shipped
+ * by a package — is invisible to it: only the Vite path ever saw imported
+ * text, because Vite resolves CSS imports before PostCSS plugins run.
+ *
+ * This module closes that gap for every other surface. It is deliberately
+ * IO-free: the caller supplies a resolver, so the same code serves the CLI
+ * (filesystem), the PostCSS plugin (filesystem), and an editor host (its own
+ * open-document map) without any of them dragging `node:fs` into a browser
+ * bundle. `resolve-import.ts` holds the Node resolver.
  *
- * **Isolation scope:** Compilation context, variant map cache, and font output
- * cache are fully isolated per instance. Google Fonts metadata (from fonts.ts)
- * is intentionally shared read-only across instances — it is populated once
- * via atomic swap and never mutated afterward, so concurrent reads are safe.
+ * What is replaced, and what is left alone:
  *
- * **Font output cache lifecycle:** `fontOutputCache` is cleared at the start
- * of each `compile()` call, so it only caches within a single compilation pass.
- * If the same compiler instance is reused across compilations (the expected SSR
- * pattern), each compilation starts with a fresh font cache.
+ * - `@import "./tokens.css";` and `@import "pkg/preset.css";` — inlined.
+ * - `@import "rainbowindex";` — left in place at the entry, since that is what
+ *   activates the compiler; dropped inside an imported file, so a preset that
+ *   imports the package cannot activate it twice. `rainbowindex/tailwind.css`
+ *   activates too, but it is a stylesheet of directives rather than a marker,
+ *   so it is inlined like any other package preset.
+ * - `@import url("https://…")`, `@import "/site.css"` — left alone. Those are
+ *   URLs for the browser to fetch, not files on disk.
+ * - `@import "a.css" screen;`, `… layer(x);`, `… supports(…);` — left alone
+ *   and warned (RI-1045). Their contents apply conditionally, and directives
+ *   have no conditional form, so silently hoisting them would be a lie.
  *
- * @example
- * ```ts
- * import { createCompiler } from "rainbowindex";
+ * Inlining is for READING. Whether the inlined text is also emitted is the
+ * caller's business: the PostCSS plugin builds its output from the AST, so
+ * nothing is duplicated there, while the CLI and `compileProject` join the
+ * inlined user CSS into their output once, in import order.
+ *
+ * One thing the inliner changes rather than copies: comments inside a PACKAGE
+ * import are dropped, and comments in the project's own files are not. A
+ * package's stylesheet is consumed as CSS, and its notes are addressed to
+ * whoever opens that package — the Tailwind preset alone was contributing
+ * 4.3 KB of section headings to every unminified build. Package-ness is
+ * inherited down the subtree, so a package's own relative imports are stripped
+ * too. See `stripCSSComments` and docs/preset-protocol.md.
+ */
+/** A file the resolver found: its identity, and its text. */
+interface ImportResolution {
+    /**
+     * Identity of the resolved file — an absolute path for the Node resolver.
+     * Used for cycle detection and as the base for the file's own imports, so
+     * it must be stable: the same file has to produce the same string.
+     */
+    path: string;
+    content: string;
+}
+/**
+ * Turn an `@import` specifier into a file, or null when it cannot be found.
+ * `from` is the identity of the importing file, or undefined at the entry.
+ */
+type ImportResolver = (specifier: string, from: string | undefined) => ImportResolution | null;
+interface InlineImportsOptions {
+    resolve: ImportResolver;
+    /** Identity of the CSS being inlined, so its relative imports resolve. */
+    from?: string;
+    /** How deep the import graph may nest before RI-1043. */
+    maxDepth?: number;
+    /** Ceiling on total inlined bytes before RI-1044. */
+    maxBytes?: number;
+}
+interface InlineImportsResult {
+    css: string;
+    warnings: string[];
+    /**
+     * Every file inlined, in first-visit order. A watcher adds these to what it
+     * watches; without them, editing an imported token file changes nothing.
+     */
+    files: string[];
+}
+/**
+ * Replace resolvable `@import` at-rules with the text they name, recursively,
+ * so the directive analyzer sees one stylesheet.
  *
- * const compiler = createCompiler();
- * const result = compiler.compile(classNames, theme);
- * const ri = compiler.createRi();
- * ```
+ * Returns the input unchanged when there is nothing to inline, which keeps the
+ * analyzer's single-entry memo hitting on repeat builds.
  */
-declare function createCompiler(): {
-    /** `authored` names the classes the user wrote by hand (`@source inline`,
-     *  `@apply`, a caller-supplied list). Omit it to treat every class as
-     *  authored — correct for callers who assembled the list themselves. */
-    compile: (classNames: Iterable<string>, theme: ResolvedTheme, authored?: ReadonlySet<string>) => CompilationResult;
-    createRi: () => (...inputs: (string | false | null | undefined)[]) => string;
-    /** Isolated font output cache for this compiler instance. Pass to
-     *  `assembleSections()` to avoid sharing module-level font state. */
-    fontOutputCache: Map<string, FontOutput>;
-};
+declare function inlineDirectiveImports(css: string, options: InlineImportsOptions): InlineImportsResult;
 
-export { type CompilationResult as C, type ParsedDirective as P, type ResolvedTheme as R, type CompiledRule as a, createThemeSnapshot as b, createCompiler as c };
+export { type ImportResolver as I, type ParsedDirective as P, type ResolvedTheme as R, type ImportResolution as a, type InlineImportsOptions as b, type InlineImportsResult as c, describeLoadedWeights as d, inlineDirectiveImports as i, weightIsLoaded as w };

package/dist/index-CNqdL5U0.d.ts

@@ -0,0 +1,56 @@
+import { a as CompilationSnapshot } from './context-DcBtnnan.js';
+
+/**
+ * ri() — class merge function.
+ * Replaces both tailwind-merge and clsx.
+ *
+ * Re-exported from the package's main and browser entries as `ri()`.
+ * Right-to-left scan: rightmost class wins when two classes set the same CSS property.
+ *
+ * This file is the pure merge runtime. Its siblings hold the other merge
+ * concepts: props.ts (claim data), resolve.ts (dual-mode claim resolution),
+ * context.ts (compilation-context lifecycle + published state), analyze.ts
+ * (editor-only merge diagnostics).
+ *
+ * ## Concurrency
+ *
+ * The default `ri()` export uses module-level state published by
+ * `finalizeCompilationContext()`. This is safe for single-compilation
+ * environments (typical browser usage, single Vite build, PostCSS).
+ *
+ * In multi-tenant / SSR / concurrent-compilation environments, use
+ * `createRi(snapshot)` instead — it captures a frozen snapshot of the
+ * compilation state and uses its own independent cache:
+ *
+ *   const snapshot = finalizeCompilationContext(ctx);
+ *   const ri = createRi(snapshot);
+ */
+/** Anything `ri()` accepts: class strings, falsy holes, and nested arrays.
+ *  Exported because `rainbowindex/recipe` builds its own inputs from it. */
+type ClassInput = string | false | null | undefined | ClassInput[];
+
+/**
+ * Merge class names with conflict resolution (replaces both tailwind-merge and clsx).
+ * Rightmost class wins when two classes set the same CSS property.
+ * Falsy values are filtered.
+ *
+ * @example
+ * ri('p-2 bg-red-500', 'p-4')           // → 'bg-red-500 p-4'
+ * ri('px-2 py-1', 'p-4')                // → 'p-4' (shorthand wins)
+ * ri('flex', isActive && 'bg-blue-500') // → 'flex bg-blue-500'
+ * ri('text-lg text-red-500')            // → 'text-lg text-red-500' (different properties)
+ */
+declare function ri(...inputs: ClassInput[]): string;
+/**
+ * Create an isolated ri() instance bound to a specific compilation snapshot.
+ * Use this in SSR or multi-compilation environments where the global ri()
+ * would be corrupted by concurrent compilations.
+ *
+ * @example
+ * const snapshot = finalizeCompilationContext(ctx);
+ * const ri = createRi(snapshot);
+ * ri('p-2 bg-red-500', 'p-4') // → 'bg-red-500 p-4'
+ */
+declare function createRi(snapshot?: CompilationSnapshot): (...inputs: ClassInput[]) => string;
+
+export { type ClassInput as C, createRi as c, ri as r };

package/dist/index-Czx-EUwh.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Generative color system — color domain model, OKLCH ramp generation,
+ * and light-dark() pairing.
+ *
+ * 2 numbers (chroma + hue) → 19-stop palette with automatic dark mode.
+ *
+ * The ramp is sampled from a fixed reference profile (`L_PROFILE` / `C_SHAPE` /
+ * `H_DRIFT`, captured from the reference palette): lightness is a curved,
+ * compressed scale (low suffix → light, high → dark), chroma is an asymmetric
+ * bell peaking at stop 500, and hue is near-flat. Dark mode is a simple ramp
+ * reversal — the dark value is the stop the ramp reaches at the mirror position
+ * (`1000 - suffix`), so stop 500 pivots to itself.
+ */
+/** Per-color dark mode override strategy. */
+type ColorDarkOverride = {
+    strategy: "mirror";
+} | {
+    strategy: "fixed";
+} | {
+    strategy: "shift";
+    chromaDelta: number;
+    hueDelta: number;
+};
+/**
+ * Color definition — discriminated union supporting:
+ * - Generative: `brand: 0.18 330;` → 19-stop palette with auto dark mode
+ * - Explicit: `accent: oklch(0.72 0.21 330);` → single color value
+ * - Pair: `surface: oklch(0.98 0.01 260) / oklch(0.15 0.01 260);` → light/dark pair
+ * - Alias: `theme: brand;` → references another color's palette via var()
+ */
+type ColorDefinition = {
+    type: "generative";
+    chroma: number;
+    hue: number;
+    dark?: ColorDarkOverride;
+    inline?: boolean;
+    parabolic?: boolean;
+    chromaBoost?: boolean;
+} | {
+    type: "explicit";
+    value: string;
+} | {
+    type: "keyword";
+    value: string;
+} | {
+    type: "pair";
+    light: string;
+    dark: string;
+} | {
+    type: "alias";
+    source: string;
+};
+/**
+ * How `dark:` and `light:` decide they apply.
+ *
+ * The point of the choice is that it has to agree with when the *tokens* flip.
+ * Tokens use `light-dark()`, which follows `color-scheme`, which the shipped
+ * preflight drives from `html[data-appearance]` on top of the OS preference. A
+ * strategy that disagrees with that gives a build two theme switches that
+ * disagree, which is what this replaced.
+ *
+ * - `media` — `@media (prefers-color-scheme: dark)`. The OS preference alone.
+ *   The historical behaviour, and the default.
+ * - `appearance` — matches exactly when `light-dark()` flips under the shipped
+ *   preflight: an explicit `html[data-appearance="dark"]`, or the OS preference
+ *   where no attribute has overridden it. Needs two rules; see `alternate` on
+ *   {@link VariantWrapper}.
+ * - `selector` — a class or any selector you toggle yourself, the strategy
+ *   Tailwind projects arrive with. The OS preference is ignored, as it is
+ *   there.
+ */
+type DarkVariantStrategy = {
+    readonly kind: "media";
+} | {
+    readonly kind: "appearance";
+} | {
+    readonly kind: "selector";
+    readonly selector: string;
+};
+interface DarkModeConfig {
+    mode: "auto" | "off";
+    chromaBoost: number;
+    hueShift: number;
+    variant: DarkVariantStrategy;
+}
+
+/**
+ * Default theme values — the static data that ships if the user writes no
+ * directives. Only the colour palette and the spacing base ship a value; every
+ * named scale starts empty and is filled by its directive.
+ */
+
+interface TextSize {
+    fontSize: string;
+    lineHeight: string;
+}
+/** Viewport units, and the container-query units that track a container
+ *  instead. Keep in step with `FLUID_UNITS` in directives/resolver.ts, which
+ *  validates the `unit` a `@fluid` block asks for. */
+type FluidUnit = "vw" | "vi" | "vmin" | "vmax" | "cqw" | "cqi" | "cqmin" | "cqmax";
+interface FluidConfig {
+    min?: string;
+    max?: string;
+    unit?: FluidUnit;
+    multiplier?: number;
+}
+interface AnimationDefinition {
+    shorthand: string;
+    keyframes: string;
+}
+interface Theme {
+    spacing: {
+        base: string;
+    };
+    colors: Record<string, ColorDefinition>;
+    text: Record<string, TextSize>;
+    breakpoints: Record<string, string>;
+    shadows: Record<string, string>;
+    weights: Record<string, number>;
+    easing: Record<string, string>;
+    fluid: FluidConfig;
+    animations: Record<string, AnimationDefinition>;
+    blur: Record<string, string>;
+}
+/**
+ * Keyword corner-shape values. `superellipse(N)` is represented separately
+ * as `{ superellipse: N }` since the numeric parameter isn't a keyword.
+ * Single source for the type, the scale table below, and the @rounded
+ * modifier parser (directives/parsers.ts).
+ */
+declare const CORNER_SHAPE_KEYWORDS: readonly ["round", "scoop", "bevel", "notch", "square", "squircle"];
+type CornerShapeKeyword = (typeof CORNER_SHAPE_KEYWORDS)[number];
+type CornerShape = CornerShapeKeyword | {
+    superellipse: number;
+};
+declare const defaultTheme: Theme;
+
+export { type AnimationDefinition as A, type ColorDefinition as C, type DarkModeConfig as D, type FluidConfig as F, type TextSize as T, type Theme as a, type CornerShape as b, defaultTheme as d };

package/dist/index-DW8YSxTz.d.ts

@@ -0,0 +1,104 @@
+import { a as CompilationSnapshot } from './context-DcBtnnan.js';
+import { R as ResolvedTheme } from './imports-C9esHd5Q.js';
+
+/**
+ * Pure `@font-face` emission — no network, no cache, no `node:` anything.
+ *
+ * Split out of `index.ts` so the CSS assembly graph stays browser-safe. The
+ * barrel next door re-exports both halves, but it also re-exports the Google
+ * client, which reaches `node:crypto` and `node:fs` through its on-disk
+ * metadata cache. `assembly.ts` needs only the emission half, and
+ * `rainbowindex/editor` needs `assembly.ts`, so importing the barrel there
+ * would drag the whole fetch/cache machinery into a bundle meant to run in
+ * vscode.dev and in the playground. Everything here is strings in, strings
+ * out: the network resolver hands its answers to the theme long before
+ * anything in this file runs.
+ */
+
+interface FontOutput {
+    imports: string[];
+    fontFaces: string[];
+    variables: string[];
+    warnings: string[];
+}
+
+interface CompiledRule {
+    /** The original class name (escaped for CSS selector). */
+    selector: string;
+    /** Sort key for deterministic ordering. */
+    sortKey: number;
+    /** CSS declarations as a string block. */
+    css: string;
+}
+interface CompilationResult {
+    /** All compiled CSS rules. */
+    rules: CompiledRule[];
+    /** @keyframes blocks needed. */
+    keyframes: string[];
+    /** @property declarations needed. */
+    properties: string[];
+    /** Map of used color hue → set of used suffixes (for token pruning). */
+    usedColorStops: Map<string, Set<number>>;
+    /**
+     * Whole `--color-<name>` token names referenced anywhere, generative stops
+     * included. `usedColorStops` cannot stand in for this: an explicit or pair
+     * entry is keyed by its undivided name, and a stop-less reference such as
+     * `var(--color-surface)` has no suffix for that map to record at all.
+     */
+    usedColorNames: Set<string>;
+    /** Set of used text size names (for token pruning). */
+    usedTextSizes: Set<string>;
+    /** Set of used font slot names (for token pruning). */
+    usedFonts: Set<string>;
+    /** Set of used rounded value names (for token pruning). */
+    /** Set of used shadow names (for token pruning). */
+    usedShadows: Set<string>;
+    /** Set of used animation shorthand names (for token pruning). */
+    usedAnimations: Set<string>;
+    /** Warnings emitted during compilation. */
+    warnings: string[];
+}
+
+/**
+ * Build a CompilationSnapshot straight from a resolved theme — no compile
+ * pass, no module-level state. Editor tooling pairs this with
+ * analyzeMerge()/createRi() for theme-accurate merge semantics.
+ */
+declare function createThemeSnapshot(theme: ResolvedTheme): CompilationSnapshot;
+/**
+ * Create an isolated compiler instance for SSR / concurrent-compilation
+ * environments. Returns a `compile()` function that does NOT touch module-level
+ * state, and a `createRi()` that produces a merge function bound to the
+ * compilation's snapshot.
+ *
+ * **Isolation scope:** Compilation context, variant map cache, and font output
+ * cache are fully isolated per instance. Google Fonts metadata (from fonts.ts)
+ * is intentionally shared read-only across instances — it is populated once
+ * via atomic swap and never mutated afterward, so concurrent reads are safe.
+ *
+ * **Font output cache lifecycle:** `fontOutputCache` is cleared at the start
+ * of each `compile()` call, so it only caches within a single compilation pass.
+ * If the same compiler instance is reused across compilations (the expected SSR
+ * pattern), each compilation starts with a fresh font cache.
+ *
+ * @example
+ * ```ts
+ * import { createCompiler } from "rainbowindex";
+ *
+ * const compiler = createCompiler();
+ * const result = compiler.compile(classNames, theme);
+ * const ri = compiler.createRi();
+ * ```
+ */
+declare function createCompiler(): {
+    /** `authored` names the classes the user wrote by hand (`@source inline`,
+     *  `@apply`, a caller-supplied list). Omit it to treat every class as
+     *  authored — correct for callers who assembled the list themselves. */
+    compile: (classNames: Iterable<string>, theme: ResolvedTheme, authored?: ReadonlySet<string>) => CompilationResult;
+    createRi: () => (...inputs: (string | false | null | undefined)[]) => string;
+    /** Isolated font output cache for this compiler instance. Pass to
+     *  `assembleSections()` to avoid sharing module-level font state. */
+    fontOutputCache: Map<string, FontOutput>;
+};
+
+export { type CompilationResult as C, type CompiledRule as a, createThemeSnapshot as b, createCompiler as c };

package/dist/index.d.ts

@@ -1,8 +1,11 @@
+export { C as CompilationResult, a as CompiledRule, c as createCompiler } from './index-DW8YSxTz.js';
 import { PluginCreator } from 'postcss';
-export { C as ColorDefinition, a as CompilationContext, b as CompilationSnapshot, D as DEFAULT_TEXT_SIZES, F as FluidConfig, T as TextSize, c as Theme, d as createCompilationContext, e as defaultTheme, f as finalizeCompilationContext, r as registerColorNames, g as registerCustomFontFamilies, h as registerCustomTextSizes, i as registerCustomUtility } from './context-B9yhJxd5.js';
-export { c as createRi, r as ri, s as safelist } from './safelist-DAkKuxCk.js';
-import { R as ResolvedTheme, P as ParsedDirective } from './index-Dx-NpFFx.js';
-export { C as CompilationResult, a as CompiledRule, c as createCompiler } from './index-Dx-NpFFx.js';
+export { C as CompilationContext, a as CompilationSnapshot, S as SerializedSnapshot, c as createCompilationContext, f as finalizeCompilationContext, h as hydrateSnapshot, p as publishSnapshot, r as registerColorNames, b as registerCustomFontFamilies, d as registerCustomTextSizes, e as registerCustomUtility, s as serializeSnapshot } from './context-DcBtnnan.js';
+export { c as createRi, r as ri } from './index-CNqdL5U0.js';
+import { R as ResolvedTheme, P as ParsedDirective, I as ImportResolver } from './imports-C9esHd5Q.js';
+export { a as ImportResolution, b as InlineImportsOptions, c as InlineImportsResult, i as inlineDirectiveImports } from './imports-C9esHd5Q.js';
+export { s as safelist } from './safelist-CH3_PywB.js';
+export { C as ColorDefinition, F as FluidConfig, T as TextSize, a as Theme, d as defaultTheme } from './index-Czx-EUwh.js';
 
 interface RainbowIndexOptions {
     sources?: string[];
@@ -21,6 +24,9 @@ interface FinalizeProjectResult {
     theme: ResolvedTheme;
     directives: ParsedDirective[];
     warnings: string[];
+    /** Codes silenced for this entry by `/* ri-disable … *\/`. A consumer that
+     *  pushes further warnings into `warnings` must push through this too. */
+    suppressed: ReadonlySet<string>;
 }
 
 interface SourceEntry {
@@ -33,9 +39,47 @@ interface CompileProjectOptions {
     classNames?: Iterable<string>;
     resolveFonts?: FontResolver;
     processCssFunctions?: boolean;
+    /** Path of the CSS entry — the base for relative `@import` specifiers. */
+    cssPath?: string;
+    /**
+     * How `@import` specifiers become files, so directives in imported files
+     * are read. Defaults to the filesystem once `cssPath` says where the entry
+     * lives; with neither, imports pass through untouched as they always have.
+     * Pass `null` to keep that behavior even when `cssPath` is set.
+     */
+    resolveImport?: ImportResolver | null;
 }
 /** compileProject returns the pipeline result unmodified — one shape, two names. */
 type CompileProjectResult = FinalizeProjectResult;
 declare function compileProject(options: CompileProjectOptions): Promise<CompileProjectResult>;
 
-export { type CompileProjectOptions, type CompileProjectResult, type RainbowIndexOptions, compileProject, rainbowindex as default };
+/**
+ * Node resolver for `@import` inlining — the only IO half of the feature.
+ *
+ * Kept apart from `imports.ts` so the inliner itself stays importable from the
+ * editor entry and from browser bundles. Nothing here is reachable from those:
+ * only the CLI, the PostCSS plugin, and `compileProject` construct a resolver.
+ *
+ * Two specifier shapes resolve:
+ *
+ * - `./tokens.css`, `../shared/theme.css` — relative to the importing file, or
+ *   to `cwd` for the entry when it has no path of its own.
+ * - `pkg/preset.css` — through `require.resolve`, so a package's `exports` map
+ *   decides, exactly as it would for JavaScript. That is what makes
+ *   `@import "rainbowindex/tailwind.css"` work without knowing where the
+ *   package lives.
+ *
+ * Everything else — remote URLs, site-root paths — is filtered out by the
+ * inliner before it ever calls this.
+ */
+
+/**
+ * Build a resolver rooted at `cwd`. Failures — missing file, unreadable file,
+ * an oversized one, a bare specifier no package provides — all return null, and
+ * the inliner turns that into one RI-1041 naming the specifier.
+ */
+declare function createNodeImportResolver(options: {
+    cwd: string;
+}): ImportResolver;
+
+export { type CompileProjectOptions, type CompileProjectResult, ImportResolver, type RainbowIndexOptions, compileProject, createNodeImportResolver, rainbowindex as default };