@affectively/aeon-pages-runtime 0.1.0

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

@@ -0,0 +1,161 @@
+/**
+ * ESI Control Language
+ *
+ * Adds conditional display and structured output validation to ESI.
+ * Uses Zod for schema validation to ensure trusted, typed results.
+ *
+ * @example
+ * ```tsx
+ * // Conditional display based on inference
+ * <ESI.If
+ *   prompt="Is this user likely to churn?"
+ *   schema={z.object({ likelihood: z.number(), reason: z.string() })}
+ *   when={(result) => result.likelihood > 0.7}
+ * >
+ *   <RetentionOffer />
+ * </ESI.If>
+ *
+ * // Structured output with Zod
+ * <ESI.Infer
+ *   schema={z.object({
+ *     sentiment: z.enum(['positive', 'negative', 'neutral']),
+ *     confidence: z.number(),
+ *     topics: z.array(z.string()),
+ *   })}
+ * >
+ *   Analyze this text: {userInput}
+ * </ESI.Infer>
+ *
+ * // Switch/match on inference result
+ * <ESI.Match
+ *   prompt="Classify user intent"
+ *   schema={z.object({ intent: z.enum(['browse', 'buy', 'support', 'leave']) })}
+ * >
+ *   <ESI.Case match={(r) => r.intent === 'buy'}><CheckoutCTA /></ESI.Case>
+ *   <ESI.Case match={(r) => r.intent === 'support'}><HelpWidget /></ESI.Case>
+ *   <ESI.Default><BrowsePrompt /></ESI.Default>
+ * </ESI.Match>
+ * ```
+ */
+import type { ZodType, ZodTypeDef } from 'zod';
+import type { ESIDirective, ESIParams, ESIResult, UserContext } from './types';
+/**
+ * ESI with Zod schema for validated, typed output
+ */
+export interface ESISchemaParams<T> extends Omit<ESIParams, 'model'> {
+    /** Zod schema for output validation */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Model defaults to 'llm' for structured output */
+    model?: 'llm';
+    /** Retry on validation failure */
+    retryOnValidationError?: boolean;
+    /** Max retries */
+    maxRetries?: number;
+}
+export interface ESISchemaResult<T> extends Omit<ESIResult, 'output'> {
+    /** Validated, typed output */
+    data?: T;
+    /** Raw output before validation */
+    rawOutput?: string;
+    /** Validation errors if any */
+    validationErrors?: string[];
+}
+/**
+ * Condition function type
+ */
+export type ESICondition<T> = (result: T, context: UserContext) => boolean;
+/**
+ * ESI.If directive - conditional rendering based on inference
+ */
+export interface ESIIfDirective<T> {
+    /** Unique ID */
+    id: string;
+    /** Prompt to evaluate */
+    prompt: string;
+    /** Schema for structured output */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Condition to check */
+    when: ESICondition<T>;
+    /** Inference params */
+    params?: Partial<ESIParams>;
+    /** Cache the condition result */
+    cacheCondition?: boolean;
+}
+/**
+ * ESI.Match directive - switch/case based on inference
+ */
+export interface ESIMatchDirective<T> {
+    /** Unique ID */
+    id: string;
+    /** Prompt to evaluate */
+    prompt: string;
+    /** Schema for structured output */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Cases to match */
+    cases: Array<{
+        match: ESICondition<T>;
+        id: string;
+    }>;
+    /** Default case ID if no match */
+    defaultCase?: string;
+    /** Inference params */
+    params?: Partial<ESIParams>;
+}
+/**
+ * Result of control flow evaluation
+ */
+export interface ESIControlResult<T> {
+    /** The directive ID */
+    id: string;
+    /** Whether condition was met (for If) */
+    conditionMet?: boolean;
+    /** Matched case ID (for Match) */
+    matchedCase?: string;
+    /** The validated data */
+    data?: T;
+    /** Inference result */
+    inferenceResult: ESISchemaResult<T>;
+}
+/**
+ * Generate a JSON schema prompt suffix for structured output
+ */
+export declare function generateSchemaPrompt<T>(schema: ZodType<T, ZodTypeDef, unknown>): string;
+/**
+ * Parse and validate LLM output against a Zod schema
+ */
+export declare function parseWithSchema<T>(output: string, schema: ZodType<T, ZodTypeDef, unknown>): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    errors: string[];
+};
+export interface ESIControlProcessor {
+    /**
+     * Process an ESI.If directive
+     */
+    processIf<T>(directive: ESIIfDirective<T>, context: UserContext): Promise<ESIControlResult<T>>;
+    /**
+     * Process an ESI.Match directive
+     */
+    processMatch<T>(directive: ESIMatchDirective<T>, context: UserContext): Promise<ESIControlResult<T>>;
+    /**
+     * Process an ESI directive with schema validation
+     */
+    processWithSchema<T>(prompt: string, schema: ZodType<T, ZodTypeDef, unknown>, params: Partial<ESIParams>, context: UserContext): Promise<ESISchemaResult<T>>;
+}
+/**
+ * Create a control processor that wraps an ESI processor
+ */
+export declare function createControlProcessor(processESI: (directive: ESIDirective, context: UserContext) => Promise<ESIResult>): ESIControlProcessor;
+/**
+ * Create an ESI.If directive
+ */
+export declare function esiIf<T>(prompt: string, schema: ZodType<T, ZodTypeDef, unknown>, when: ESICondition<T>, options?: Partial<ESIParams>): ESIIfDirective<T>;
+/**
+ * Create an ESI.Match directive
+ */
+export declare function esiMatch<T>(prompt: string, schema: ZodType<T, ZodTypeDef, unknown>, cases: Array<{
+    match: ESICondition<T>;
+    id: string;
+}>, defaultCase?: string, options?: Partial<ESIParams>): ESIMatchDirective<T>;

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

@@ -0,0 +1,198 @@
+/**
+ * ESI React Components
+ *
+ * Bring AI to templates with declarative components.
+ *
+ * @example
+ * ```tsx
+ * import { ESI } from '@affectively/aeon-flux/esi';
+ *
+ * function PersonalizedGreeting() {
+ *   return (
+ *     <ESI.Infer
+ *       model="llm"
+ *       contextAware
+ *       signals={['emotion', 'time']}
+ *     >
+ *       Generate a warm greeting for the user
+ *     </ESI.Infer>
+ *   );
+ * }
+ *
+ * function EmotionAwareContent({ content }) {
+ *   return (
+ *     <ESI.Infer
+ *       model="llm"
+ *       temperature={0.7}
+ *       fallback="Here's today's content..."
+ *     >
+ *       {`Adapt this content to be emotionally supportive: ${content}`}
+ *     </ESI.Infer>
+ *   );
+ * }
+ * ```
+ */
+import { type ReactNode, type FC } from 'react';
+import type { ESIConfig, ESIDirective, ESIModel, ESIProcessor, ESIResult, UserContext } from './types';
+interface ESIContextValue {
+    processor: ESIProcessor;
+    userContext: UserContext | null;
+    enabled: boolean;
+    process: (directive: ESIDirective) => Promise<ESIResult>;
+    processWithStream: (directive: ESIDirective, onChunk: (chunk: string) => void) => Promise<ESIResult>;
+}
+export interface ESIProviderProps {
+    children: ReactNode;
+    config?: Partial<ESIConfig>;
+    userContext?: UserContext;
+    processor?: ESIProcessor;
+}
+/**
+ * ESI Provider - enables ESI components in the tree
+ */
+export declare const ESIProvider: FC<ESIProviderProps>;
+/**
+ * Hook to access ESI context
+ */
+export declare function useESI(): ESIContextValue;
+export interface ESIInferProps {
+    /** The prompt - can be children or explicit prop */
+    children?: ReactNode;
+    prompt?: string;
+    /** Model to use */
+    model?: ESIModel;
+    /** Model variant */
+    variant?: string;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** System prompt */
+    system?: string;
+    /** Enable streaming */
+    stream?: boolean;
+    /** Fallback content if inference fails */
+    fallback?: ReactNode;
+    /** Loading content */
+    loading?: ReactNode;
+    /** Inject user context */
+    contextAware?: boolean;
+    /** Context signals to include */
+    signals?: Array<'emotion' | 'preferences' | 'history' | 'time' | 'device'>;
+    /** Cache TTL in seconds */
+    cacheTtl?: number;
+    /** Custom render function */
+    render?: (result: ESIResult) => ReactNode;
+    /** Class name for wrapper */
+    className?: string;
+    /** Callback when inference completes */
+    onComplete?: (result: ESIResult) => void;
+    /** Callback on error */
+    onError?: (error: string) => void;
+}
+/**
+ * ESI Inference Component
+ *
+ * @example
+ * ```tsx
+ * <ESI.Infer model="llm" temperature={0.7}>
+ *   Write a haiku about React
+ * </ESI.Infer>
+ * ```
+ */
+export declare const ESIInfer: FC<ESIInferProps>;
+export interface ESIEmbedProps {
+    children: ReactNode;
+    onComplete?: (embedding: number[]) => void;
+    onError?: (error: string) => void;
+}
+/**
+ * ESI Embed Component - generates embeddings
+ *
+ * @example
+ * ```tsx
+ * <ESI.Embed onComplete={(embedding) => console.log(embedding)}>
+ *   Text to embed
+ * </ESI.Embed>
+ * ```
+ */
+export declare const ESIEmbed: FC<ESIEmbedProps>;
+export interface ESIEmotionProps {
+    children: ReactNode;
+    contextAware?: boolean;
+    onComplete?: (result: {
+        emotion: string;
+        confidence: number;
+    }) => void;
+    onError?: (error: string) => void;
+}
+/**
+ * ESI Emotion Component - detects emotion from text
+ *
+ * @example
+ * ```tsx
+ * <ESI.Emotion onComplete={({ emotion }) => setMood(emotion)}>
+ *   {userInput}
+ * </ESI.Emotion>
+ * ```
+ */
+export declare const ESIEmotion: FC<ESIEmotionProps>;
+export interface ESIVisionProps {
+    src: string;
+    prompt: string;
+    fallback?: ReactNode;
+    loading?: ReactNode;
+    className?: string;
+    onComplete?: (result: ESIResult) => void;
+    onError?: (error: string) => void;
+}
+/**
+ * ESI Vision Component - analyzes images
+ *
+ * @example
+ * ```tsx
+ * <ESI.Vision
+ *   src={base64Image}
+ *   prompt="Describe what you see"
+ *   fallback="Unable to analyze image"
+ * />
+ * ```
+ */
+export declare const ESIVision: FC<ESIVisionProps>;
+export interface UseESIInferOptions extends Omit<ESIInferProps, 'children' | 'loading' | 'fallback' | 'render' | 'className'> {
+    autoRun?: boolean;
+}
+/**
+ * Hook for programmatic ESI inference
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { run, result, isLoading, error } = useESIInfer({
+ *     model: 'llm',
+ *     contextAware: true,
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => run('Generate a greeting')}>
+ *       {isLoading ? 'Generating...' : result?.output || 'Click to generate'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useESIInfer(options?: UseESIInferOptions): {
+    run: (prompt: string) => Promise<ESIResult | null>;
+    result: ESIResult | null;
+    isLoading: boolean;
+    error: string | null;
+    reset: () => void;
+};
+export declare const ESI: {
+    Provider: FC<ESIProviderProps>;
+    Infer: FC<ESIInferProps>;
+    Embed: FC<ESIEmbedProps>;
+    Emotion: FC<ESIEmotionProps>;
+    Vision: FC<ESIVisionProps>;
+};
+export default ESI;

package/dist/router/esi.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Edge Side Inference (ESI) Processor
+ *
+ * Like Varnish ESI but for AI - brings inference to the edge at render time.
+ * Components can embed AI directly in templates for dynamic, personalized content.
+ */
+import type { ESIConfig, ESIDirective, ESIModel, ESIParams, ESIProcessor, ESIResult, UserContext } from './types';
+export declare class EdgeWorkersESIProcessor implements ESIProcessor {
+    name: string;
+    private config;
+    private warmupPromise?;
+    constructor(config?: Partial<ESIConfig>);
+    warmup(): Promise<void>;
+    isModelAvailable(model: ESIModel): boolean;
+    process(directive: ESIDirective, context: UserContext): Promise<ESIResult>;
+    processBatch(directives: ESIDirective[], context: UserContext): Promise<ESIResult[]>;
+    stream(directive: ESIDirective, context: UserContext, onChunk: (chunk: string) => void): Promise<ESIResult>;
+    private callEdgeWorkers;
+    private getEndpointForModel;
+    private buildRequestBody;
+    private parseResponse;
+}
+/**
+ * Create an ESI directive for LLM inference
+ */
+export declare function esiInfer(prompt: string, options?: Partial<ESIParams>): ESIDirective;
+/**
+ * Create an ESI directive for embeddings
+ */
+export declare function esiEmbed(text: string): ESIDirective;
+/**
+ * Create an ESI directive for emotion detection
+ */
+export declare function esiEmotion(text: string, contextAware?: boolean): ESIDirective;
+/**
+ * Create an ESI directive for vision (image analysis)
+ */
+export declare function esiVision(base64Image: string, prompt: string, options?: Partial<ESIParams>): ESIDirective;
+/**
+ * Create a context-aware ESI directive
+ * Automatically injects user context into the prompt
+ */
+export declare function esiWithContext(prompt: string, signals?: ESIDirective['signals'], options?: Partial<ESIParams>): ESIDirective;
+export { ESIConfig, ESIDirective, ESIResult, ESIProcessor, ESIModel };

package/dist/router/heuristic-adapter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Heuristic Router Adapter
+ *
+ * Zero-latency personalized routing using pure heuristics.
+ * No external API calls - all decisions made locally via WASM-compatible logic.
+ *
+ * Signals used:
+ * - User tier → feature gating
+ * - Viewport → responsive layout selection, density
+ * - Custom signals → theme/accent derivation (configurable)
+ * - Navigation history → component ordering, speculation
+ * - Time of day → theme suggestion
+ * - Connection speed → prefetch depth
+ */
+import type { ComponentNode, ComponentTree, EmotionState, RouteDecision, RouterAdapter, ThemeMode, UserContext, UserTier } from './types';
+/**
+ * Feature flags configuration by tier
+ */
+export type TierFeatures = Record<UserTier, Record<string, boolean>>;
+/**
+ * Custom signal processor for deriving values from user context
+ */
+export interface SignalProcessor {
+    /** Derive accent color from context */
+    deriveAccent?: (context: UserContext) => string;
+    /** Derive theme from context */
+    deriveTheme?: (context: UserContext) => ThemeMode;
+    /** Custom component relevance scoring */
+    scoreRelevance?: (node: ComponentNode, context: UserContext) => number;
+    /** Custom navigation prediction */
+    predictNavigation?: (currentPath: string, context: UserContext) => string[];
+}
+/**
+ * Heuristic adapter configuration
+ */
+export interface HeuristicAdapterConfig {
+    /** Feature flags by tier (optional - defaults to all features enabled) */
+    tierFeatures?: TierFeatures;
+    /** Default accent color when no signal processor provided */
+    defaultAccent?: string;
+    /** Custom signal processing */
+    signals?: SignalProcessor;
+    /** Default paths to suggest when no history available */
+    defaultPaths?: string[];
+    /** Maximum number of paths to speculate */
+    maxSpeculationPaths?: number;
+}
+export declare class HeuristicAdapter implements RouterAdapter {
+    name: string;
+    private config;
+    constructor(config?: HeuristicAdapterConfig);
+    route(path: string, context: UserContext, tree: ComponentTree): Promise<RouteDecision>;
+    speculate(currentPath: string, context: UserContext): Promise<string[]>;
+    personalizeTree(tree: ComponentTree, decision: RouteDecision): ComponentTree;
+    emotionToAccent(emotionState: EmotionState): string;
+    private generateSessionId;
+}

package/dist/router/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Aeon Router - Personalized Routing System
+ *
+ * The website comes to the person - adaptive routing with:
+ * - User context signals (emotion, tier, preferences)
+ * - Speculative prefetching
+ * - Edge Side Inference (ESI)
+ * - Pluggable adapters (heuristic, AI, hybrid)
+ */
+export type { EmotionState, Viewport, ConnectionType, UserTier, UserContext, ThemeMode, LayoutDensity, LayoutType, SkeletonHints, RouteDecision, ComponentNode, ComponentTree, ComponentTreeSchema, RouterAdapter, AIRouterConfig, SpeculationConfig, PersonalizationConfig, RouterConfig, RouterConfigWithESI, ESIModel, ESIContentType, ESIParams, ESIContent, ESIDirective, ESIResult, ESIProcessor, ESIConfig, } from './types';
+export { DEFAULT_ROUTER_CONFIG, DEFAULT_ESI_CONFIG } from './types';
+export { EdgeWorkersESIProcessor, esiInfer, esiEmbed, esiEmotion, esiVision, esiWithContext, } from './esi';
+export { ESI, ESIProvider, ESIInfer, ESIEmbed, ESIEmotion, ESIVision, useESI, useESIInfer, } from './esi-react';
+export type { ESIProviderProps, ESIInferProps, ESIEmbedProps, ESIEmotionProps, ESIVisionProps, UseESIInferOptions, } from './esi-react';
+export { HeuristicAdapter } from './heuristic-adapter';
+export type { HeuristicAdapterConfig, TierFeatures, SignalProcessor, } from './heuristic-adapter';
+export { extractUserContext, createContextMiddleware, setContextCookies, addSpeculationHeaders, } from './context-extractor';
+export type { ContextExtractorOptions } from './context-extractor';
+export { SpeculationManager, supportsSpeculationRules, supportsLinkPrefetch, autoInitSpeculation, createSpeculationHook, } from './speculation';
+export type { SpeculationOptions, SpeculationState, } from './speculation';
+export { parseWithSchema, generateSchemaPrompt, createControlProcessor, esiIf, esiMatch, } from './esi-control';
+export type { ESICondition, ESIIfDirective, ESIMatchDirective, ESIControlResult, ESISchemaParams, ESISchemaResult, ESIControlProcessor, } from './esi-control';
+export { ESIControl, ESIStructured, ESIIf, ESIMatch, ESICase, ESIDefault, ESICollaborative, ESIReflect, ESIOptimize, ESIAuto, } from './esi-control-react';
+export type { ESIStructuredProps, ESIIfProps, ESIMatchProps, ESICaseProps, ESIDefaultProps, ESICollaborativeProps, ESIReflectProps, ESIOptimizeProps, ESIAutoProps, OptimizeMeta, } from './esi-control-react';