@retrivora-ai/rag-engine 2.0.2 → 2.0.4

package/dist/index-DcklhThn.d.ts

@@ -0,0 +1,532 @@
+import { CSSProperties, MouseEvent, ReactNode, ElementType } from 'react';
+import { y as Product, m as UIConfig, j as RagMessage, q as VectorMatch, J as UITransformationResponse, i as RagConfig, I as ILLMProvider, f as IngestDocument, C as ChatMessage, c as ChatResponse, z as RetrievalResult, n as UniversalRagConfig } from './ILLMProvider-0rRBYbVW.js';
+
+interface ArchitectureCardProps {
+    icon: ReactNode;
+    title: string;
+    description: string;
+    badge: string;
+    badgeColor: string;
+}
+interface Snippet {
+    id: string;
+    title: string;
+    description: string;
+    code: string;
+    language: string;
+}
+interface PipelineStep {
+    step: string;
+    Icon: ElementType;
+    title: string;
+    desc: string;
+    colors: {
+        from: string;
+        to: string;
+    };
+}
+interface ProviderPill {
+    Icon: ElementType;
+    label: string;
+}
+type ChatViewportSize = 'compact' | 'medium' | 'large';
+interface ChatWindowProps {
+    /** Additional className for the wrapper div */
+    className?: string;
+    /** Inline styles for the wrapper div */
+    style?: CSSProperties;
+    /** Called when the close button is clicked (for widget mode) */
+    onClose?: () => void;
+    /** Whether to show a close (X) button in the header */
+    showClose?: boolean;
+    /** Called when the user starts dragging the resize handle */
+    onResizeStart?: (e: MouseEvent) => void;
+    /** Called when the user clicks the reset size button */
+    onResetResize?: () => void;
+    /** Whether the window has been resized from its default */
+    isResized?: boolean;
+    /** Called when the user clicks the maximize/minimize button */
+    onMaximize?: () => void;
+    /** Whether the window is currently maximized */
+    isMaximized?: boolean;
+    /** Called when the user clicks 'Add to Cart' on a product */
+    onAddToCart?: (product: Product) => void;
+    /** Optional custom API URL to send chat messages to */
+    apiUrl?: string;
+    /**
+     * Base URL for Retrivora SDK history/feedback/sessions endpoints.
+     * Defaults to '/api/retrivora'. Set this to match your catch-all route location.
+     */
+    retrivoraApiBase?: string;
+    /** Optional custom headers to send with the chat request */
+    headers?: Record<string, string>;
+}
+interface ChatWidgetProps {
+    /** Position of the floating button. Defaults to bottom-right. */
+    position?: 'bottom-right' | 'bottom-left';
+    /** Called when the user clicks 'Add to Cart' on a product */
+    onAddToCart?: (product: Product) => void;
+    /** Optional custom API URL to send chat messages to */
+    apiUrl?: string;
+    /**
+     * Base URL for Retrivora SDK history/feedback/sessions endpoints.
+     * Defaults to '/api/retrivora'.
+     */
+    retrivoraApiBase?: string;
+    /** Optional custom headers to send with the chat request */
+    headers?: Record<string, string>;
+}
+interface MessageBubbleProps {
+    message: RagMessage;
+    sources?: VectorMatch[];
+    isStreaming?: boolean;
+    primaryColor: string;
+    accentColor: string;
+    onAddToCart?: (product: Product) => void;
+    viewportSize?: ChatViewportSize;
+    /** Called when the user clicks thumbs up or thumbs down on an assistant message */
+    onFeedback?: (messageId: string, rating: 'thumbs_up' | 'thumbs_down') => void;
+}
+interface ProductCardProps {
+    product: Product;
+    primaryColor?: string;
+    onAddToCart?: (product: Product) => void;
+}
+interface ProductCarouselProps {
+    products: Product[];
+    primaryColor?: string;
+    onAddToCart?: (product: Product) => void;
+}
+interface DocumentUploadProps {
+    /** Optional namespace for the upload */
+    namespace?: string;
+    /** Callback when upload completes */
+    onUploadComplete?: (results: unknown) => void;
+    /** Additional className */
+    className?: string;
+}
+interface SourceCardProps {
+    source: VectorMatch;
+    index: number;
+}
+interface ClientConfig {
+    projectId: string;
+    ui: Required<UIConfig>;
+    embedding?: {
+        model?: string;
+        dimensions?: number;
+    };
+}
+interface ConfigProviderProps {
+    config?: {
+        projectId?: string;
+        ui?: Partial<UIConfig>;
+        embedding?: {
+            model?: string;
+            dimensions?: number;
+        };
+    };
+    children: ReactNode;
+}
+
+/**
+ * Primary rendering outcome types supported by the decision engine.
+ */
+type RenderType = 'text' | 'table' | 'carousel' | 'chart' | 'mixed' | 'card' | 'none';
+/**
+ * Chart sub-types available when renderType === 'chart'.
+ */
+type ChartType = 'bar' | 'line' | 'pie' | 'scatter';
+/**
+ * High-level intent classification categories.
+ */
+type IntentCategory = 'information_lookup' | 'product_search' | 'recommendation' | 'comparison' | 'analytics' | 'trend_analysis' | 'ranking' | 'summarization';
+/**
+ * Individual section specifier for multi-section (mixed) responses.
+ */
+interface RenderSectionDecision {
+    type: RenderType;
+    chartType?: ChartType;
+    title?: string;
+}
+/**
+ * Final decision produced by the Visualization Decision Engine.
+ */
+interface RenderDecision {
+    /** Primary rendering format selected */
+    renderType: RenderType;
+    /** Specific chart sub-type if renderType === 'chart' */
+    chartType?: ChartType;
+    /** Confidence score between 0.0 and 1.0 */
+    confidence: number;
+    /** Human-readable explanation of why this decision was reached */
+    reason: string;
+    /** Sub-sections if renderType === 'mixed' */
+    sections?: RenderSectionDecision[];
+}
+/**
+ * Context provided to the intent classifier & decision engine rules.
+ */
+interface DecisionContext {
+    /** Original user prompt/query string */
+    userQuery: string;
+    /** Vector DB retrieved documents / context records */
+    retrievedDocuments?: VectorMatch[];
+    /** Optional LLM text response if already available */
+    llmResponse?: string;
+    /** Additional custom metadata or config settings */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Interface implemented by rule strategies in the Rule Engine.
+ */
+interface IRenderRule {
+    /** Unique name of the decision rule */
+    name: string;
+    /** Precedence score (higher priority rules run first) */
+    priority: number;
+    /** Evaluate the rule against current query context and classified intent */
+    evaluate(context: DecisionContext, intent: IntentCategory): RenderDecision | null;
+}
+/**
+ * Interface implemented by pluggable Renderer Strategies in RendererRegistry.
+ */
+interface IRendererStrategy {
+    /** Render type identifier handled by this strategy */
+    type: RenderType | string;
+    /** Transform input data into a standardized UITransformationResponse payload */
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+
+interface DataSignals {
+    rowCount: number;
+    hasNumericFields: boolean;
+    hasDateFields: boolean;
+    hasCategoricalFields: boolean;
+    isProductLike: boolean;
+    numericFieldCount: number;
+    categoricalFieldCount: number;
+}
+declare class IntentClassifier {
+    /**
+     * Fast, zero-latency classifier that maps a user query and optional data context
+     * into a high-level IntentCategory.
+     */
+    static classify(context: DecisionContext): {
+        intent: IntentCategory;
+        signals: DataSignals;
+    };
+    /**
+     * Extract key data structure signals from retrieved documents.
+     */
+    static extractDataSignals(context: DecisionContext): DataSignals;
+    private static isInformationLookup;
+    private static isComparisonQuery;
+    private static isProductQuery;
+    private static isRecommendationQuery;
+    private static isTrendQuery;
+    private static isRankingQuery;
+    private static isAnalyticsQuery;
+}
+
+declare class RuleEngine {
+    private rules;
+    constructor();
+    /**
+     * Register standard rules in priority order.
+     */
+    private registerDefaultRules;
+    /**
+     * Add or replace a rule in the engine.
+     * Automatically keeps rules sorted by descending priority.
+     */
+    registerRule(rule: IRenderRule): void;
+    /**
+     * Evaluate context against rules in descending priority order.
+     * Returns the first non-null RenderDecision.
+     */
+    evaluate(context: DecisionContext, intent: IntentCategory): RenderDecision;
+    /**
+     * List all registered rules.
+     */
+    getRegisteredRules(): Array<{
+        name: string;
+        priority: number;
+    }>;
+}
+
+declare class TextRendererStrategy implements IRendererStrategy {
+    readonly type = "text";
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+declare class TableRendererStrategy implements IRendererStrategy {
+    readonly type = "table";
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+declare class CarouselRendererStrategy implements IRendererStrategy {
+    readonly type = "carousel";
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+declare class ChartRendererStrategy implements IRendererStrategy {
+    readonly type = "chart";
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+declare class MixedRendererStrategy implements IRendererStrategy {
+    readonly type = "mixed";
+    render(data: unknown, options?: Record<string, unknown>): UITransformationResponse;
+}
+declare class RendererRegistry {
+    private static strategies;
+    /**
+     * Register a new renderer strategy.
+     * Enables seamless addition of custom visualizers (Timeline, Maps, Flow Diagrams, etc.).
+     */
+    static registerStrategy(strategy: IRendererStrategy): void;
+    /**
+     * Retrieve a registered renderer strategy by type string.
+     */
+    static getStrategy(type: string): IRendererStrategy;
+    /**
+     * Check if a renderer strategy is registered.
+     */
+    static hasStrategy(type: string): boolean;
+    /**
+     * List all registered strategy types.
+     */
+    static getRegisteredTypes(): string[];
+}
+
+/**
+ * High-Performance Visualization Decision Engine.
+ * Intelligently determines whether to render text, table, carousel, chart, or mixed sections
+ * BEFORE expensive visual generation or LLM visual calls execute.
+ */
+declare class VisualizationDecisionEngine {
+    private static ruleEngine;
+    private static cache;
+    /**
+     * Evaluate user query, documents, and context to produce a RenderDecision.
+     * Execution time is < 1ms for cached or rule-matched queries.
+     */
+    static decideVisualization(userQuery: string, retrievedDocuments?: VectorMatch[], llmResponse?: string, metadata?: Record<string, unknown>): RenderDecision;
+    /**
+     * Convenience helper to decide AND render the data into a UITransformationResponse.
+     */
+    static render(userQuery: string, retrievedDocuments?: VectorMatch[], llmResponse?: string, metadata?: Record<string, unknown>): UITransformationResponse;
+    /**
+     * Register a custom rule in the rule engine.
+     */
+    static registerRule(rule: IRenderRule): void;
+    /**
+     * Register a custom renderer strategy.
+     */
+    static registerRendererStrategy(strategy: IRendererStrategy): void;
+    /**
+     * Clear the decision cache.
+     */
+    static clearCache(): void;
+    /**
+     * Get size of current decision cache.
+     */
+    static getCacheSize(): number;
+}
+/**
+ * Top-level function export matching prompt specification.
+ */
+declare function decideVisualization(userQuery: string, retrievedDocuments?: VectorMatch[], llmResponse?: string, metadata?: Record<string, unknown>): RenderDecision;
+
+/**
+ * DocumentChunker — splits long text into overlapping chunks
+ * suitable for vector embedding and retrieval.
+ *
+ * Strategy: sentence-aware sliding window
+ *   1. Split on sentence boundaries
+ *   2. Accumulate sentences into chunks up to `chunkSize` characters
+ *   3. Carry over `chunkOverlap` characters from the previous chunk
+ */
+interface Chunk {
+    id: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+interface ChunkOptions {
+    /** Target chunk size in characters (default 1000) */
+    chunkSize?: number;
+    /** Overlap between consecutive chunks in characters (default 200) */
+    chunkOverlap?: number;
+    /** Source document identifier used as ID prefix */
+    docId?: string | number;
+    /** Extra metadata to attach to every chunk */
+    metadata?: Record<string, unknown>;
+    /** Characters used to split text, in order of priority */
+    separators?: string[];
+}
+declare class DocumentChunker {
+    private readonly chunkSize;
+    private readonly chunkOverlap;
+    private readonly separators;
+    constructor(chunkSize?: number, chunkOverlap?: number, separators?: string[]);
+    /**
+     * Split a single text string into overlapping chunks using a recursive strategy.
+     * Preserves structural boundaries (Markdown headers) where possible.
+     */
+    chunk(text: string, options?: ChunkOptions): Chunk[];
+    private recursiveSplit;
+    chunkMany(documents: Array<{
+        content: string;
+        docId?: string | number;
+        metadata?: Record<string, unknown>;
+    }>): Chunk[];
+}
+
+/**
+ * Pipeline — orchestrates the RAG flow: Embed → Search → Augment → Generate.
+ *
+ * Features:
+ * - Lazy initialization of providers
+ * - Batch processing with retry logic
+ * - Smart embedding strategy (integrated / separate / external)
+ * - Error recovery for transient failures
+ * - Multi-tenancy support via namespacing
+ * - LRU-bounded embedding cache (max 500 entries, prevents memory leaks)
+ * - Full observability tracing (latency, tokens, hallucination scoring)
+ */
+declare class Pipeline {
+    private config;
+    private vectorDB;
+    private graphDB?;
+    private llmProvider;
+    private embeddingProvider;
+    private llmRouter;
+    private chunker;
+    private llamaIngestor?;
+    private entityExtractor?;
+    private reranker;
+    private agent?;
+    private mcpRegistry?;
+    private multiAgentCoordinator?;
+    /** LRU-bounded cache: avoids re-embedding identical queries within the same process. */
+    private embeddingCache;
+    private initialised;
+    /** Namespace-specific static cold context cache for CAG */
+    private coldContexts;
+    constructor(config: RagConfig);
+    /**
+     * Expose the underlying LLM provider (set after initialize()).
+     * Used by the stream handler to pass to UITransformer.analyzeAndDecide().
+     */
+    getLLMProvider(): ILLMProvider | undefined;
+    initialize(): Promise<void>;
+    private loadColdContext;
+    /**
+     * Ingest documents with automatic chunking, embedding, and batch upsert.
+     */
+    ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{
+        docId: string | number;
+        chunksIngested: number;
+    }>>;
+    /** Step 1: Chunk the document content. */
+    private prepareChunks;
+    /**
+     * Step 2: Generate embeddings for chunks with retry logic.
+     * Uses batchEmbed when available for efficiency; falls back to sequential embedding.
+     */
+    private processEmbeddings;
+    /** Step 3: Upsert chunks to vector database with retry logic. */
+    private processUpserts;
+    /** Step 4: Optional graph-based entity extraction and ingestion. */
+    private processGraphIngestion;
+    runNormalQuery(question: string, history?: ChatMessage[], namespace?: string): Promise<{
+        reply: string;
+        sources: any[];
+    }>;
+    ask(question: string, history?: ChatMessage[], namespace?: string): Promise<ChatResponse>;
+    askStream(question: string, history?: ChatMessage[], namespace?: string): AsyncIterable<string | ChatResponse>;
+    /**
+     * High-performance streaming RAG flow.
+     * Yields text chunks first, then the retrieval metadata + observability trace at the end.
+     *
+     * Latency optimizations:
+     * - Strategy classification runs in parallel with query embedding (saves ~400ms)
+     * - Hallucination scoring is fire-and-forget (doesn't block metadata yield)
+     * - UITransformation is computed after text streaming and emitted with metadata
+     * - SchemaMapper.train runs while answer generation streams
+     */
+    askStreamInternal(question: string, history?: ChatMessage[], namespace?: string): AsyncIterable<string | ChatResponse>;
+    /**
+     * Universal retrieval method combining all enabled providers.
+     * Uses an LRU-bounded embedding cache to avoid re-embedding the same query.
+     */
+    private generateUiTransformation;
+    private applyStructuredFilters;
+    private resolveNumericPredicateValue;
+    private extractNumericValueFromContent;
+    private matchesNumericPredicate;
+    private normalizeComparableField;
+    private fieldSimilarityScore;
+    private fieldTokens;
+    private toFiniteNumber;
+    retrieve(query: string, options: {
+        namespace?: string;
+        topK?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<RetrievalResult>;
+    /** Rewrite the user query for better retrieval performance. */
+    private rewriteQuery;
+    /** Generate 3-5 short, relevant questions based on the vector database content. */
+    getSuggestions(query: string, namespace?: string): Promise<string[]>;
+}
+
+/**
+ * Public SDK facade matching the prompt-level Retrivora API.
+ *
+ * It keeps provider details behind configuration and delegates execution to the
+ * existing Pipeline implementation.
+ */
+declare class Retrivora {
+    private readonly pipeline;
+    readonly config: RagConfig;
+    constructor(config?: UniversalRagConfig);
+    initialize(): Promise<void>;
+    ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{
+        docId: string | number;
+        chunksIngested: number;
+    }>>;
+    ask(question: string, history?: ChatMessage[], namespace?: string): Promise<ChatResponse>;
+    askStream(question: string, history?: ChatMessage[], namespace?: string): AsyncIterable<string | ChatResponse>;
+    getPipeline(): Pipeline;
+}
+
+/**
+ * Named SDK exceptions make failures machine-readable for host applications.
+ */
+type RetrivoraErrorCode = 'PROVIDER_NOT_FOUND' | 'EMBEDDING_FAILED' | 'RETRIEVAL_FAILED' | 'RATE_LIMITED' | 'CONFIGURATION_ERROR' | 'AUTHENTICATION_ERROR';
+declare class RetrivoraError extends Error {
+    readonly code: RetrivoraErrorCode;
+    readonly details?: unknown;
+    constructor(message: string, code: RetrivoraErrorCode, details?: unknown);
+}
+declare class ProviderNotFoundException extends RetrivoraError {
+    constructor(providerType: string, provider: string, details?: unknown);
+}
+declare class EmbeddingFailedException extends RetrivoraError {
+    constructor(message?: string, details?: unknown);
+}
+declare class RetrievalException extends RetrivoraError {
+    constructor(message?: string, details?: unknown);
+}
+declare class RateLimitException extends RetrivoraError {
+    constructor(message?: string, details?: unknown);
+}
+declare class ConfigurationException extends RetrivoraError {
+    constructor(message: string, details?: unknown);
+}
+declare class AuthenticationException extends RetrivoraError {
+    constructor(message?: string, details?: unknown);
+}
+/**
+ * Wraps any unknown error into an appropriate RetrivoraError subclass.
+ */
+declare function wrapError(err: unknown, defaultCode: RetrivoraErrorCode, defaultMessage?: string): RetrivoraError;
+
+export { AuthenticationException as A, DocumentChunker as B, type ChatWidgetProps as C, type DocumentUploadProps as D, EmbeddingFailedException as E, MixedRendererStrategy as F, Pipeline as G, type PipelineStep as H, type IRenderRule as I, type ProviderPill as J, type RenderSectionDecision as K, type Snippet as L, type MessageBubbleProps as M, TextRendererStrategy as N, wrapError as O, type ProductCardProps as P, RateLimitException as R, type SourceCardProps as S, TableRendererStrategy as T, VisualizationDecisionEngine as V, type ChatWindowProps as a, type ConfigProviderProps as b, type ClientConfig as c, type ProductCarouselProps as d, type ChartType as e, type Chunk as f, type ChunkOptions as g, ConfigurationException as h, type DecisionContext as i, type IRendererStrategy as j, type IntentCategory as k, IntentClassifier as l, ProviderNotFoundException as m, type RenderDecision as n, type RenderType as o, RendererRegistry as p, RetrievalException as q, Retrivora as r, RetrivoraError as s, type RetrivoraErrorCode as t, RuleEngine as u, decideVisualization as v, type ArchitectureCardProps as w, CarouselRendererStrategy as x, ChartRendererStrategy as y, type ChatViewportSize as z };

package/dist/index.css

@@ -52,6 +52,7 @@
     --color-blue-300: oklch(80.9% 0.105 251.813);
     --color-blue-400: oklch(70.7% 0.165 254.624);
     --color-blue-500: oklch(62.3% 0.214 259.815);
+    --color-blue-600: oklch(54.6% 0.245 262.881);
     --color-blue-700: oklch(48.8% 0.243 264.376);
     --color-blue-800: oklch(42.4% 0.199 265.638);
     --color-blue-900: oklch(37.9% 0.146 265.522);
@@ -113,6 +114,7 @@
     --container-xs: 20rem;
     --container-md: 28rem;
     --container-2xl: 42rem;
+    --container-4xl: 56rem;
     --text-xs: 0.75rem;
     --text-xs--line-height: calc(1 / 0.75);
     --text-sm: 0.875rem;
@@ -126,6 +128,7 @@
     --font-weight-medium: 500;
     --font-weight-semibold: 600;
     --font-weight-bold: 700;
+    --tracking-tight: -0.025em;
     --tracking-wider: 0.05em;
     --tracking-widest: 0.1em;
     --leading-tight: 1.25;
@@ -618,6 +621,9 @@
   .h-\[400\%\] {
     height: 400%;
   }
+  .h-\[600px\] {
+    height: 600px;
+  }
   .h-full {
     height: 100%;
   }
@@ -729,6 +735,9 @@
   .max-w-2xl {
     max-width: var(--container-2xl);
   }
+  .max-w-4xl {
+    max-width: var(--container-4xl);
+  }
   .max-w-\[90\%\] {
     max-width: 90%;
   }
@@ -976,6 +985,13 @@
       margin-block-end: calc(calc(var(--spacing) * 5) * calc(1 - var(--tw-space-y-reverse)));
     }
   }
+  .space-y-8 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 8) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 8) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
   .divide-y {
     :where(& > :not(:last-child)) {
       --tw-divide-y-reverse: 0;
@@ -1458,9 +1474,6 @@
   .py-4 {
     padding-block: calc(var(--spacing) * 4);
   }
-  .py-12 {
-    padding-block: calc(var(--spacing) * 12);
-  }
   .pt-1 {
     padding-top: calc(var(--spacing) * 1);
   }
@@ -1476,6 +1489,9 @@
   .pb-4 {
     padding-bottom: calc(var(--spacing) * 4);
   }
+  .pb-6 {
+    padding-bottom: calc(var(--spacing) * 6);
+  }
   .text-center {
     text-align: center;
   }
@@ -1543,6 +1559,10 @@
     --tw-font-weight: var(--font-weight-semibold);
     font-weight: var(--font-weight-semibold);
   }
+  .tracking-tight {
+    --tw-tracking: var(--tracking-tight);
+    letter-spacing: var(--tracking-tight);
+  }
   .tracking-wider {
     --tw-tracking: var(--tracking-wider);
     letter-spacing: var(--tracking-wider);
@@ -1587,6 +1607,9 @@
   .text-amber-950 {
     color: var(--color-amber-950);
   }
+  .text-blue-600 {
+    color: var(--color-blue-600);
+  }
   .text-blue-700 {
     color: var(--color-blue-700);
   }
@@ -2213,6 +2236,11 @@
       border-color: var(--color-emerald-500);
     }
   }
+  .focus\:ring-blue-500 {
+    &:focus {
+      --tw-ring-color: var(--color-blue-500);
+    }
+  }
   .active\:scale-95 {
     &:active {
       --tw-scale-x: 95%;
@@ -2268,6 +2296,11 @@
       grid-template-columns: repeat(2, minmax(0, 1fr));
     }
   }
+  .md\:p-12 {
+    @media (width >= 48rem) {
+      padding: calc(var(--spacing) * 12);
+    }
+  }
   .md\:opacity-0 {
     @media (width >= 48rem) {
       opacity: 0%;
@@ -2381,6 +2414,16 @@
       }
     }
   }
+  .dark\:border-slate-700 {
+    @media (prefers-color-scheme: dark) {
+      border-color: var(--color-slate-700);
+    }
+  }
+  .dark\:border-slate-800 {
+    @media (prefers-color-scheme: dark) {
+      border-color: var(--color-slate-800);
+    }
+  }
   .dark\:border-white\/5 {
     @media (prefers-color-scheme: dark) {
       border-color: color-mix(in srgb, #fff 5%, transparent);
@@ -2990,6 +3033,11 @@
       color: var(--color-rose-400);
     }
   }
+  .dark\:text-slate-100 {
+    @media (prefers-color-scheme: dark) {
+      color: var(--color-slate-100);
+    }
+  }
   .dark\:text-slate-300 {
     @media (prefers-color-scheme: dark) {
       color: var(--color-slate-300);