rainbowindex 0.6.0 → 0.7.0

package/dist/{index-4Kyaq3IZ.d.ts → imports-C9esHd5Q.d.ts}

@@ -1,4 +1,4 @@
-import { C as ColorDefinition, D as DarkModeConfig, j as CornerShape, A as AnimationDefinition, F as FluidConfig, b as CompilationSnapshot } from './index-DSgpB6bS.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";
@@ -73,23 +73,6 @@ declare function weightIsLoaded(weight: number, fonts: readonly FontSlot[]): boo
  *  `Inter 300–900; Fira Code 400, 700`. */
 declare function describeLoadedWeights(fonts: readonly FontSlot[]): string;
 
-/**
- * Font loading system — @font directive processing, @font-face generation,
- * metrics-adjusted fallbacks for zero CLS.
- *
- * 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.
- */
-
-interface FontOutput {
-    imports: string[];
-    fontFaces: string[];
-    variables: string[];
-    warnings: string[];
-}
-
 /**
  * Raw-extractable directive names — the single source for the DirectiveType
  * union and the name sets in directives/index.ts (which add the PostCSS-only
@@ -212,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.
  *
- * **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.
+ * 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.
  *
- * **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.
+ * What is replaced, and what is left alone:
  *
- * @example
- * ```ts
- * import { createCompiler } from "rainbowindex";
+ * - `@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.
+ *
+ * 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, describeLoadedWeights as d, weightIsLoaded as w };
+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 @@
-import { R as ResolvedTheme, P as ParsedDirective } from './index-4Kyaq3IZ.js';
-export { C as CompilationResult, a as CompiledRule, c as createCompiler } from './index-4Kyaq3IZ.js';
+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, 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 './index-DSgpB6bS.js';
-export { c as createRi, r as ri, s as safelist } from './safelist-CGCtF-Fr.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[];
@@ -36,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 };

package/dist/index.mjs

@@ -3,32 +3,50 @@ import {
 } from "./chunk-PD4ZXGJ6.mjs";
 import {
   postcss_default
-} from "./chunk-3LWJTLOJ.mjs";
+} from "./chunk-RC6DDE4L.mjs";
 import {
   finalizeProjectCompilation,
   resolveGoogleFonts
-} from "./chunk-WK6S4HTC.mjs";
+} from "./chunk-2T7V5XLK.mjs";
+import {
+  createNodeImportResolver
+} from "./chunk-W756NVYI.mjs";
 import {
   analyzeProjectCSSMemo,
   createCompiler,
   extractClassesFromSource,
+  inlineDirectiveImports,
   pushWarningsDeduped
-} from "./chunk-KSNYSR3C.mjs";
+} from "./chunk-FJOZJIKB.mjs";
+import {
+  defaultTheme
+} from "./chunk-L56IRO7A.mjs";
 import {
   createCompilationContext,
   createRi,
-  defaultTheme,
   finalizeCompilationContext,
+  hydrateSnapshot,
+  publishSnapshot,
   registerColorNames,
   registerCustomFontFamilies,
   registerCustomTextSizes,
   registerCustomUtility,
-  ri
-} from "./chunk-6U4IOFOS.mjs";
+  ri,
+  serializeSnapshot
+} from "./chunk-XQGSG2HK.mjs";
 
 // src/project/index.ts
+import { dirname } from "path";
 async function compileProject(options) {
-  const analysis = analyzeProjectCSSMemo(options.css);
+  const resolveImport = options.resolveImport === void 0 ? options.cssPath === void 0 ? null : createNodeImportResolver({ cwd: dirname(options.cssPath) }) : options.resolveImport;
+  const inlined = resolveImport === null ? { css: options.css, warnings: [] } : inlineDirectiveImports(options.css, { resolve: resolveImport, from: options.cssPath });
+  const analysis = analyzeProjectCSSMemo(inlined.css);
+  pushWarningsDeduped(
+    analysis.warnings,
+    inlined.warnings,
+    analysis.warningSeen,
+    analysis.suppressed
+  );
   const classNames = /* @__PURE__ */ new Set();
   if (options.classNames) {
     for (const cls of options.classNames) {
@@ -51,7 +69,8 @@ async function compileProject(options) {
     );
   }
   return finalizeProjectCompilation({
-    css: options.css,
+    css: inlined.css,
+    cssPath: options.cssPath,
     classNames,
     authoredClassNames: authored,
     analysis,
@@ -65,14 +84,19 @@ export {
   compileProject,
   createCompilationContext,
   createCompiler,
+  createNodeImportResolver,
   createRi,
   postcss_default as default,
   defaultTheme,
   finalizeCompilationContext,
+  hydrateSnapshot,
+  inlineDirectiveImports,
+  publishSnapshot,
   registerColorNames,
   registerCustomFontFamilies,
   registerCustomTextSizes,
   registerCustomUtility,
   ri,
-  safelist
+  safelist,
+  serializeSnapshot
 };