@affectively/aeon-pages-runtime 0.3.0 → 0.5.0

package/dist/router/context-extractor.d.ts

@@ -36,6 +36,8 @@ export declare function addSpeculationHeaders(response: Response, prefetch: stri
 export interface ESIState {
     /** User subscription tier for feature gating */
     userTier: UserTier;
+    /** Admin flag - bypasses ALL tier restrictions */
+    isAdmin?: boolean;
     /** Current emotional state for personalization */
     emotionState?: {
         primary: string;

package/dist/router/esi-control-react.d.ts

@@ -234,12 +234,333 @@ export interface ESIAutoProps<T> {
  * - Quick mode → Basic (fast, single pass)
  */
 export declare function ESIAuto<T>({ children, prompt, schema, render, collaborativeThreshold, optimizeSettings, fallback, loading, className, }: ESIAutoProps<T>): JSX.Element;
+export interface ESIShowProps {
+    /** Condition to evaluate - AI will return true/false */
+    condition: string;
+    /** Content to show if condition is true */
+    children: ReactNode;
+    /** Content to show if condition is false */
+    fallback?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Cache TTL */
+    cacheTtl?: number;
+    /** Callback */
+    onEvaluate?: (result: boolean) => void;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Simple boolean show/hide based on AI evaluation
+ * @example
+ * <ESI.Show condition="User seems frustrated based on their message history">
+ *   <CalmingMessage />
+ * </ESI.Show>
+ */
+export declare function ESIShow({ condition, children, fallback, loading, cacheTtl, onEvaluate, className, }: ESIShowProps): JSX.Element;
+export interface ESIHideProps {
+    /** Condition to evaluate - content hidden if true */
+    condition: string;
+    /** Content to show if condition is false */
+    children: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Cache TTL */
+    cacheTtl?: number;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Hide content based on AI evaluation
+ * @example
+ * <ESI.Hide condition="User is a minor">
+ *   <AdultContent />
+ * </ESI.Hide>
+ */
+export declare function ESIHide({ condition, children, loading, cacheTtl, className, }: ESIHideProps): JSX.Element;
+export interface ESIWhenProps {
+    /** Condition description */
+    condition: string;
+    /** Content to render when true */
+    children: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Cache TTL */
+    cacheTtl?: number;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Render content only when condition is met
+ * @example
+ * <ESI.When condition="It's the user's birthday">
+ *   <BirthdayBanner />
+ * </ESI.When>
+ */
+export declare function ESIWhen({ condition, children, loading, cacheTtl, className }: ESIWhenProps): JSX.Element;
+export interface ESIUnlessProps {
+    /** Condition description - renders if false */
+    condition: string;
+    /** Content to render when condition is false */
+    children: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Cache TTL */
+    cacheTtl?: number;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Render content unless condition is met
+ * @example
+ * <ESI.Unless condition="User has completed onboarding">
+ *   <OnboardingPrompt />
+ * </ESI.Unless>
+ */
+export declare function ESIUnless({ condition, children, loading, cacheTtl, className }: ESIUnlessProps): JSX.Element;
+export interface ESITierGateProps {
+    /** Minimum tier required */
+    minTier: 'free' | 'starter' | 'pro' | 'enterprise';
+    /** Content for users who meet tier requirement */
+    children: ReactNode;
+    /** Content for users below tier (upgrade prompt) */
+    fallback?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Gate content by user tier
+ * Admins bypass ALL tier restrictions
+ * @example
+ * <ESI.TierGate minTier="pro" fallback={<UpgradePrompt />}>
+ *   <AdvancedFeature />
+ * </ESI.TierGate>
+ */
+export declare function ESITierGate({ minTier, children, fallback, className }: ESITierGateProps): JSX.Element;
+export interface ESIEmotionGateProps {
+    /** Emotion(s) that allow access */
+    allow?: string[];
+    /** Emotion(s) that block access */
+    block?: string[];
+    /** Valence range [min, max] (-1 to 1) */
+    valenceRange?: [number, number];
+    /** Arousal range [min, max] (0 to 1) */
+    arousalRange?: [number, number];
+    /** Content to show when conditions met */
+    children: ReactNode;
+    /** Content when conditions not met */
+    fallback?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Gate content by emotion state
+ * @example
+ * <ESI.EmotionGate allow={['calm', 'focused']} fallback={<TakeABreakPrompt />}>
+ *   <ComplexTask />
+ * </ESI.EmotionGate>
+ */
+export declare function ESIEmotionGate({ allow, block, valenceRange, arousalRange, children, fallback, className, }: ESIEmotionGateProps): JSX.Element;
+export interface ESITimeGateProps {
+    /** Start hour (0-23) */
+    after?: number;
+    /** End hour (0-23) */
+    before?: number;
+    /** Days of week (0=Sunday, 6=Saturday) */
+    days?: number[];
+    /** Content to show when in time range */
+    children: ReactNode;
+    /** Content when outside time range */
+    fallback?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Gate content by time of day
+ * @example
+ * <ESI.TimeGate after={9} before={17} days={[1,2,3,4,5]}>
+ *   <BusinessHoursContent />
+ * </ESI.TimeGate>
+ */
+export declare function ESITimeGate({ after, before, days, children, fallback, className, }: ESITimeGateProps): JSX.Element;
+export interface ESIABTestProps {
+    /** Test name for tracking */
+    name: string;
+    /** Variants to test */
+    variants: {
+        [key: string]: ReactNode;
+    };
+    /** Prompt to select variant (AI decides) */
+    selectionPrompt?: string;
+    /** Use random selection instead of AI */
+    random?: boolean;
+    /** Callback when variant selected */
+    onSelect?: (variant: string) => void;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * A/B testing with AI-based or random selection
+ * @example
+ * <ESI.ABTest
+ *   name="checkout-button"
+ *   variants={{
+ *     control: <Button>Buy Now</Button>,
+ *     variant_a: <Button color="green">Purchase</Button>,
+ *     variant_b: <Button size="large">Get It Now</Button>
+ *   }}
+ *   selectionPrompt="Pick the variant most likely to convert based on user emotion"
+ * />
+ */
+export declare function ESIABTest({ name, variants, selectionPrompt, random, onSelect, loading, className, }: ESIABTestProps): JSX.Element;
+export interface ESIForEachProps<T> {
+    /** Prompt to generate the list */
+    prompt: string;
+    /** Zod schema for each item */
+    itemSchema: ZodType<T, ZodTypeDef, unknown>;
+    /** Render function for each item */
+    render: (item: T, index: number) => ReactNode;
+    /** Max items to generate */
+    maxItems?: number;
+    /** Empty state */
+    empty?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Wrapper element */
+    as?: 'div' | 'ul' | 'ol' | 'span';
+    /** Class name */
+    className?: string;
+}
+/**
+ * Generate and render a list of items
+ * @example
+ * <ESI.ForEach
+ *   prompt="Generate 5 personalized activity suggestions"
+ *   itemSchema={z.object({ title: z.string(), description: z.string() })}
+ *   render={(item, i) => <ActivityCard key={i} {...item} />}
+ * />
+ */
+export declare function ESIForEach<T>({ prompt, itemSchema, render, maxItems, empty, loading, as: Wrapper, className, }: ESIForEachProps<T>): JSX.Element;
+export interface ESIFirstProps {
+    /** Prompt with context for evaluation */
+    context?: string;
+    /** Children should be ESI.When components */
+    children: ReactNode;
+    /** Fallback if no condition matches */
+    fallback?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Render the first child whose condition evaluates to true
+ * @example
+ * <ESI.First fallback={<DefaultContent />}>
+ *   <ESI.When condition="User is angry"><CalmingContent /></ESI.When>
+ *   <ESI.When condition="User is confused"><HelpContent /></ESI.When>
+ *   <ESI.When condition="User is happy"><CelebrateContent /></ESI.When>
+ * </ESI.First>
+ */
+export declare function ESIFirst({ context, children, fallback, loading, className, }: ESIFirstProps): JSX.Element;
+export interface ESIClampProps {
+    /** Prompt to generate a number */
+    prompt: string;
+    /** Minimum value */
+    min: number;
+    /** Maximum value */
+    max: number;
+    /** Render function */
+    render: (value: number) => ReactNode;
+    /** Default value if generation fails */
+    defaultValue?: number;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Generate a clamped numeric value
+ * @example
+ * <ESI.Clamp
+ *   prompt="Rate the urgency of this message from 1-10"
+ *   min={1}
+ *   max={10}
+ *   render={(urgency) => <UrgencyBadge level={urgency} />}
+ * />
+ */
+export declare function ESIClamp({ prompt, min, max, render, defaultValue, loading, className, }: ESIClampProps): JSX.Element;
+export interface ESISelectProps<T extends string> {
+    /** Prompt for selection */
+    prompt: string;
+    /** Available options */
+    options: T[];
+    /** Render function for selected option */
+    render: (selected: T) => ReactNode;
+    /** Default if selection fails */
+    defaultOption?: T;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Callback */
+    onSelect?: (selected: T) => void;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Select from predefined options
+ * @example
+ * <ESI.Select
+ *   prompt="What tone should we use for this user?"
+ *   options={['formal', 'casual', 'playful', 'empathetic']}
+ *   render={(tone) => <Message tone={tone} />}
+ * />
+ */
+export declare function ESISelect<T extends string>({ prompt, options, render, defaultOption, loading, onSelect, className, }: ESISelectProps<T>): JSX.Element;
+export interface ESIScoreProps {
+    /** What to score */
+    prompt: string;
+    /** Render function */
+    render: (score: number, label: string) => ReactNode;
+    /** Score thresholds and labels */
+    thresholds?: {
+        value: number;
+        label: string;
+    }[];
+    /** Loading state */
+    loading?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * Generate a normalized 0-1 score with label
+ * @example
+ * <ESI.Score
+ *   prompt="Rate the user's engagement level"
+ *   render={(score, label) => <EngagementMeter value={score} label={label} />}
+ * />
+ */
+export declare function ESIScore({ prompt, render, thresholds, loading, className, }: ESIScoreProps): JSX.Element;
 export declare const ESIControl: {
     Structured: typeof ESIStructured;
     If: typeof ESIIf;
+    Show: typeof ESIShow;
+    Hide: typeof ESIHide;
+    When: typeof ESIWhen;
+    Unless: typeof ESIUnless;
     Match: typeof ESIMatch;
     Case: typeof ESICase;
     Default: typeof ESIDefault;
+    First: typeof ESIFirst;
+    TierGate: typeof ESITierGate;
+    EmotionGate: typeof ESIEmotionGate;
+    TimeGate: typeof ESITimeGate;
+    ForEach: typeof ESIForEach;
+    Select: typeof ESISelect;
+    ABTest: typeof ESIABTest;
+    Clamp: typeof ESIClamp;
+    Score: typeof ESIScore;
     Collaborative: typeof ESICollaborative;
     Reflect: typeof ESIReflect;
     Optimize: typeof ESIOptimize;

package/dist/router/esi-format-react.d.ts

@@ -0,0 +1,283 @@
+/**
+ * ESI Format Components (React)
+ *
+ * Output transformation wrappers for ESI components.
+ * These components wrap other ESI components and transform their output.
+ *
+ * @example
+ * ```tsx
+ * // Render inference output as markdown
+ * <ESI.Markdown>
+ *   <ESI.Infer>Generate documentation for this API endpoint</ESI.Infer>
+ * </ESI.Markdown>
+ *
+ * // Render LaTeX math expressions
+ * <ESI.Latex>
+ *   <ESI.Infer>Write the quadratic formula</ESI.Infer>
+ * </ESI.Latex>
+ *
+ * // Pretty-print JSON output
+ * <ESI.Json>
+ *   <ESI.Structured schema={mySchema}>Analyze this data</ESI.Structured>
+ * </ESI.Json>
+ * ```
+ */
+import { type ReactNode, type FC } from 'react';
+/** Supported wrapper element types */
+type WrapperElement = 'div' | 'span' | 'pre' | 'code' | 'section' | 'article' | 'aside';
+export interface ESIFormatProps {
+    /** ESI component(s) to wrap */
+    children: ReactNode;
+    /** CSS class for the output container */
+    className?: string;
+    /** Custom wrapper element */
+    as?: WrapperElement;
+    /** Fallback content if transformation fails */
+    fallback?: ReactNode;
+    /** Whether to sanitize output (default: true for HTML-producing formats) */
+    sanitize?: boolean;
+}
+export interface ESIMarkdownProps extends ESIFormatProps {
+    /** GitHub Flavored Markdown support */
+    gfm?: boolean;
+    /** Enable syntax highlighting for code blocks */
+    syntaxHighlight?: boolean;
+    /** Theme for syntax highlighting */
+    syntaxTheme?: 'light' | 'dark' | 'auto';
+    /** Allow raw HTML in markdown (default: false for security) */
+    allowHtml?: boolean;
+    /** Custom link target */
+    linkTarget?: '_blank' | '_self' | '_parent' | '_top';
+}
+export interface ESILatexProps extends ESIFormatProps {
+    /** Rendering mode */
+    mode?: 'inline' | 'block' | 'auto';
+    /** Display mode (larger, centered equations) */
+    displayMode?: boolean;
+    /** Error color for invalid LaTeX */
+    errorColor?: string;
+    /** Trust user input (allow dangerous commands) */
+    trust?: boolean;
+}
+export interface ESIJsonProps extends Omit<ESIFormatProps, 'as'> {
+    /** Custom wrapper element */
+    as?: WrapperElement;
+    /** Indentation spaces */
+    indent?: number;
+    /** Syntax highlighting */
+    syntaxHighlight?: boolean;
+    /** Theme for syntax highlighting */
+    theme?: 'light' | 'dark' | 'auto';
+    /** Collapse objects/arrays by default */
+    collapsed?: boolean;
+    /** Max depth before collapsing */
+    collapseDepth?: number;
+    /** Enable copy button */
+    copyable?: boolean;
+}
+export interface ESIPlaintextProps extends Omit<ESIFormatProps, 'as'> {
+    /** Custom wrapper element */
+    as?: WrapperElement;
+    /** Preserve whitespace */
+    preserveWhitespace?: boolean;
+    /** Word wrap */
+    wordWrap?: boolean;
+    /** Max width (characters) before wrapping */
+    maxWidth?: number;
+}
+/** Supported code-specialized models */
+export type CodeModel = 'codestral' | 'deepseek' | 'starcoder' | 'codellama' | 'qwen-coder' | 'claude' | 'gpt-4' | 'llm';
+export interface ESICodeProps extends Omit<ESIFormatProps, 'as'> {
+    /** Custom wrapper element */
+    as?: WrapperElement;
+    /** Programming language for syntax highlighting */
+    language?: string;
+    /** Auto-detect language using AI inference */
+    autoDetect?: boolean;
+    /** Generate code from natural language description (text-to-code) */
+    generateFrom?: string;
+    /** Code model to use for generation/detection */
+    model?: CodeModel;
+    /** Show line numbers */
+    lineNumbers?: boolean;
+    /** Starting line number */
+    startLine?: number;
+    /** Highlight specific lines */
+    highlightLines?: number[];
+    /** Theme */
+    theme?: 'light' | 'dark' | 'auto';
+    /** Enable copy button */
+    copyable?: boolean;
+    /** Temperature for code generation (lower = more deterministic) */
+    temperature?: number;
+    /** Callback when language is detected */
+    onLanguageDetect?: (language: string) => void;
+    /** Callback when code is generated */
+    onGenerate?: (code: string, language: string) => void;
+}
+/**
+ * Render ESI output as markdown
+ *
+ * @example
+ * ```tsx
+ * <ESI.Markdown gfm>
+ *   <ESI.Infer>Generate API documentation for the /users endpoint</ESI.Infer>
+ * </ESI.Markdown>
+ * ```
+ */
+export declare const ESIMarkdown: FC<ESIMarkdownProps>;
+/**
+ * Render ESI output as LaTeX math
+ *
+ * @example
+ * ```tsx
+ * <ESI.Latex displayMode>
+ *   <ESI.Infer>Write the quadratic formula in LaTeX</ESI.Infer>
+ * </ESI.Latex>
+ * ```
+ */
+export declare const ESILatex: FC<ESILatexProps>;
+/**
+ * Render ESI output as formatted JSON
+ *
+ * @example
+ * ```tsx
+ * <ESI.Json indent={4} syntaxHighlight>
+ *   <ESI.Structured schema={dataSchema}>Analyze this data</ESI.Structured>
+ * </ESI.Json>
+ * ```
+ */
+export declare const ESIJson: FC<ESIJsonProps>;
+/**
+ * Render ESI output as plain text (strips formatting)
+ *
+ * @example
+ * ```tsx
+ * <ESI.Plaintext preserveWhitespace>
+ *   <ESI.Infer>Generate ASCII art</ESI.Infer>
+ * </ESI.Plaintext>
+ * ```
+ */
+export declare const ESIPlaintext: FC<ESIPlaintextProps>;
+/**
+ * Render ESI output as code with optional syntax highlighting and AI generation
+ *
+ * @example
+ * ```tsx
+ * // Wrap inference output as code
+ * <ESI.Code language="typescript" lineNumbers>
+ *   <ESI.Infer>Write a TypeScript function to sort an array</ESI.Infer>
+ * </ESI.Code>
+ *
+ * // Generate code from natural language (text-to-code)
+ * <ESI.Code
+ *   generateFrom="A React hook that fetches user data"
+ *   language="typescript"
+ *   model="codestral"
+ * />
+ *
+ * // Auto-detect language
+ * <ESI.Code autoDetect model="deepseek">
+ *   {someCodeString}
+ * </ESI.Code>
+ * ```
+ */
+export declare const ESICode: FC<ESICodeProps>;
+/** Schema.org types for microdata */
+export type SchemaOrgType = 'Article' | 'BlogPosting' | 'CreativeWork' | 'Event' | 'HowTo' | 'NewsArticle' | 'Organization' | 'Person' | 'Place' | 'Product' | 'Recipe' | 'Review' | 'Thing' | 'WebPage';
+/** Extracted semantic topic */
+export interface SemanticTopic {
+    /** Topic label */
+    label: string;
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Schema.org type */
+    schemaType?: SchemaOrgType;
+    /** Related keywords */
+    keywords?: string[];
+    /** Embedding vector (if requested) */
+    embedding?: number[];
+}
+/** Extracted entity */
+export interface SemanticEntity {
+    /** Entity text */
+    text: string;
+    /** Entity type (person, place, org, etc.) */
+    type: 'person' | 'place' | 'organization' | 'date' | 'money' | 'product' | 'event' | 'other';
+    /** Schema.org type */
+    schemaType?: SchemaOrgType;
+    /** Start position in text */
+    start?: number;
+    /** End position in text */
+    end?: number;
+}
+/** Extracted emotion from text */
+export interface SemanticEmotion {
+    /** Primary emotion */
+    primary: string;
+    /** Valence: negative (-1) to positive (1) */
+    valence: number;
+    /** Arousal: calm (0) to excited (1) */
+    arousal: number;
+    /** Confidence 0-1 */
+    confidence: number;
+}
+export interface ESISemanticProps extends Omit<ESIFormatProps, 'as'> {
+    /** Custom wrapper element */
+    as?: WrapperElement;
+    /** Text to analyze (or children) */
+    text?: string;
+    /** Output format */
+    format?: 'microdata' | 'jsonld' | 'rdfa' | 'tags';
+    /** Include embeddings in output */
+    includeEmbeddings?: boolean;
+    /** Maximum topics to extract */
+    maxTopics?: number;
+    /** Minimum confidence threshold */
+    minConfidence?: number;
+    /** Schema.org type hint */
+    schemaType?: SchemaOrgType;
+    /** Extract named entities using entity model */
+    extractEntities?: boolean;
+    /** Extract emotion using emotion model */
+    extractEmotion?: boolean;
+    /** Custom topic vocabulary (for domain-specific topics) */
+    vocabulary?: string[];
+    /** Callback with extracted data */
+    onExtract?: (data: {
+        topics: SemanticTopic[];
+        entities: SemanticEntity[];
+        emotion?: SemanticEmotion;
+    }) => void;
+}
+/**
+ * Extract semantic topics and generate structured HTML with microdata
+ *
+ * @example
+ * ```tsx
+ * // Extract topics as microdata
+ * <ESI.Semantic format="microdata" maxTopics={5}>
+ *   <ESI.Infer>Summarize this article about climate change</ESI.Infer>
+ * </ESI.Semantic>
+ *
+ * // Generate JSON-LD structured data
+ * <ESI.Semantic format="jsonld" schemaType="Article">
+ *   {articleText}
+ * </ESI.Semantic>
+ *
+ * // Extract as tags for display
+ * <ESI.Semantic format="tags" extractEntities>
+ *   {content}
+ * </ESI.Semantic>
+ * ```
+ */
+export declare const ESISemantic: FC<ESISemanticProps>;
+export declare const ESIFormat: {
+    Markdown: FC<ESIMarkdownProps>;
+    Latex: FC<ESILatexProps>;
+    Json: FC<ESIJsonProps>;
+    Plaintext: FC<ESIPlaintextProps>;
+    Code: FC<ESICodeProps>;
+    Semantic: FC<ESISemanticProps>;
+};
+export default ESIFormat;