@affectively/aeon-pages-runtime 0.1.0

package/dist/navigation.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Aeon Navigation Engine
+ *
+ * Cutting-edge navigation with:
+ * - Speculative prefetching
+ * - Total preload capability
+ * - View transitions
+ * - Presence awareness
+ * - Predictive navigation
+ */
+import { AeonRouter } from './router.js';
+import { NavigationCache, type CachedSession } from './cache';
+export interface NavigationOptions {
+    transition?: 'slide' | 'fade' | 'morph' | 'none';
+    replace?: boolean;
+}
+export interface PrefetchOptions {
+    data?: boolean;
+    presence?: boolean;
+    priority?: 'high' | 'normal' | 'low';
+}
+export interface NavigationState {
+    current: string;
+    previous: string | null;
+    history: string[];
+    isNavigating: boolean;
+}
+export interface PresenceInfo {
+    route: string;
+    count: number;
+    editing: number;
+    hot: boolean;
+    users?: {
+        userId: string;
+        name?: string;
+    }[];
+}
+export interface PredictedRoute {
+    route: string;
+    probability: number;
+    reason: 'history' | 'hover' | 'visibility' | 'community';
+}
+type NavigationListener = (state: NavigationState) => void;
+type PresenceListener = (route: string, presence: PresenceInfo) => void;
+export declare class AeonNavigationEngine {
+    private router;
+    private cache;
+    private state;
+    private navigationListeners;
+    private presenceListeners;
+    private presenceCache;
+    private navigationHistory;
+    private pendingPrefetches;
+    private observer;
+    private sessionFetcher?;
+    private presenceFetcher?;
+    constructor(options?: {
+        router?: AeonRouter;
+        cache?: NavigationCache;
+        initialRoute?: string;
+        sessionFetcher?: (sessionId: string) => Promise<CachedSession>;
+        presenceFetcher?: (route: string) => Promise<PresenceInfo>;
+    });
+    /**
+     * Navigate to a route with optional view transition
+     */
+    navigate(href: string, options?: NavigationOptions): Promise<void>;
+    /**
+     * Prefetch a route
+     */
+    prefetch(href: string, options?: PrefetchOptions): Promise<void>;
+    /**
+     * Prefetch presence for a route
+     */
+    prefetchPresence(route: string): Promise<PresenceInfo | null>;
+    /**
+     * Check if a route is preloaded
+     */
+    isPreloaded(href: string): boolean;
+    /**
+     * Get cached presence for a route
+     */
+    getPresence(route: string): PresenceInfo | null;
+    /**
+     * Observe links for visibility-based prefetch
+     */
+    observeLinks(container: Element): () => void;
+    /**
+     * Predict next navigation destinations
+     */
+    predict(currentRoute: string): PredictedRoute[];
+    /**
+     * Go back in navigation history
+     */
+    back(): Promise<void>;
+    /**
+     * Get current navigation state
+     */
+    getState(): NavigationState;
+    /**
+     * Subscribe to navigation changes
+     */
+    subscribe(listener: NavigationListener): () => void;
+    /**
+     * Subscribe to presence changes for a route
+     */
+    subscribePresence(listener: PresenceListener): () => void;
+    /**
+     * Preload all routes (total preload strategy)
+     */
+    preloadAll(onProgress?: (loaded: number, total: number) => void): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): import("./cache").CacheStats;
+    private getSession;
+    private updateDOM;
+    private recordNavigation;
+    private notifyListeners;
+    private notifyPresenceListeners;
+}
+export declare function getNavigator(): AeonNavigationEngine;
+export declare function setNavigator(navigator: AeonNavigationEngine): void;
+export {};

package/dist/predictor.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Aeon Navigation Predictor
+ *
+ * Predicts where users will navigate next based on:
+ * 1. Personal navigation history (Markov chain)
+ * 2. Collaborative signals (where is the community going?)
+ * 3. Time-based patterns (Monday morning vs Friday afternoon)
+ * 4. Content signals (came from search → exploring)
+ *
+ * The predictor itself is an Aeon entity - it syncs across nodes
+ * to build community navigation patterns.
+ */
+export interface PredictedRoute {
+    route: string;
+    probability: number;
+    reason: 'history' | 'hover' | 'visibility' | 'community' | 'time' | 'content';
+    confidence: number;
+}
+export interface NavigationRecord {
+    from: string;
+    to: string;
+    timestamp: number;
+    duration: number;
+    source?: 'click' | 'back' | 'forward' | 'direct';
+}
+export interface CommunityPattern {
+    route: string;
+    popularity: number;
+    avgTimeSpent: number;
+    nextRoutes: {
+        route: string;
+        count: number;
+    }[];
+}
+export interface PredictorConfig {
+    historyWeight: number;
+    communityWeight: number;
+    timeWeight: number;
+    decayFactor: number;
+    minProbability: number;
+    maxPredictions: number;
+}
+export declare class NavigationPredictor {
+    private config;
+    private history;
+    private transitionMatrix;
+    private communityPatterns;
+    private timePatterns;
+    constructor(config?: Partial<PredictorConfig>);
+    /**
+     * Record a navigation event
+     */
+    record(record: NavigationRecord): void;
+    /**
+     * Predict next navigation destinations from current route
+     */
+    predict(currentRoute: string): PredictedRoute[];
+    /**
+     * Predict from personal navigation history (Markov chain)
+     */
+    private predictFromHistory;
+    /**
+     * Predict from community patterns
+     */
+    private predictFromCommunity;
+    /**
+     * Predict from time-based patterns
+     */
+    private predictFromTime;
+    /**
+     * Merge a prediction into the predictions map
+     */
+    private mergePrediction;
+    /**
+     * Apply decay to old history records
+     */
+    private applyDecay;
+    /**
+     * Update community patterns from external sync
+     */
+    updateCommunityPatterns(patterns: Map<string, CommunityPattern>): void;
+    /**
+     * Get current transition matrix (for syncing)
+     */
+    getTransitionMatrix(): Map<string, Map<string, number>>;
+    /**
+     * Import transition matrix from sync
+     */
+    importTransitionMatrix(matrix: Map<string, Map<string, number>>): void;
+    /**
+     * Get statistics about the predictor
+     */
+    getStats(): {
+        totalRecords: number;
+        uniqueRoutes: number;
+        transitionPairs: number;
+        communityPatterns: number;
+    };
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Export for persistence
+     */
+    export(): {
+        history: NavigationRecord[];
+        transitionMatrix: [string, [string, number][]][];
+        timePatterns: [string, [number, number][]][];
+    };
+    /**
+     * Import from persistence
+     */
+    import(data: {
+        history?: NavigationRecord[];
+        transitionMatrix?: [string, [string, number][]][];
+        timePatterns?: [string, [number, number][]][];
+    }): void;
+}
+export declare function getPredictor(): NavigationPredictor;
+export declare function setPredictor(predictor: NavigationPredictor): void;

package/dist/registry.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Aeon Route Registry - Collaborative route management
+ *
+ * Routes are stored as Aeon entities, enabling:
+ * - Distributed sync across nodes
+ * - Conflict resolution for concurrent route mutations
+ * - Schema versioning for route structure changes
+ */
+import type { RouteMetadata, RouteOperation } from './types';
+interface RegistryOptions {
+    syncMode: 'distributed' | 'local';
+    versioningEnabled: boolean;
+}
+interface AeonRoute {
+    path: string;
+    component: string;
+    metadata: RouteMetadata;
+    version: string;
+}
+/**
+ * Collaborative route registry using Aeon distributed sync
+ */
+export declare class AeonRouteRegistry {
+    private routes;
+    private coordinator;
+    private reconciler;
+    private versions;
+    private syncMode;
+    private versioningEnabled;
+    private mutationCallbacks;
+    private connectedSockets;
+    constructor(options: RegistryOptions);
+    private initializeAeonModules;
+    /**
+     * Add a new route collaboratively
+     */
+    addRoute(path: string, component: string, metadata: RouteMetadata): Promise<void>;
+    /**
+     * Update an existing route
+     */
+    updateRoute(path: string, updates: Partial<AeonRoute>): Promise<void>;
+    /**
+     * Remove a route
+     */
+    removeRoute(path: string): Promise<void>;
+    /**
+     * Get a route by path
+     */
+    getRoute(path: string): AeonRoute | undefined;
+    /**
+     * Get session ID for a path
+     */
+    getSessionId(path: string): string;
+    /**
+     * Get all routes
+     */
+    getAllRoutes(): AeonRoute[];
+    /**
+     * Subscribe to route mutations
+     */
+    subscribeToMutations(callback: (operation: RouteOperation) => void): () => void;
+    /**
+     * Handle WebSocket connection for Aeon sync
+     */
+    handleConnect(ws: unknown): void;
+    /**
+     * Handle WebSocket disconnection
+     */
+    handleDisconnect(ws: unknown): void;
+    /**
+     * Handle incoming sync message
+     */
+    handleSyncMessage(ws: unknown, message: unknown): void;
+    private notifyMutation;
+    private handleSyncCompleted;
+    private applyRemoteOperation;
+    private persistRoute;
+}
+export {};

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

@@ -0,0 +1,31 @@
+/**
+ * User Context Extractor
+ *
+ * Middleware that extracts UserContext from HTTP requests.
+ * Gathers signals from headers, cookies, and request properties.
+ */
+import type { EmotionState, UserContext, UserTier } from './types';
+export interface ContextExtractorOptions {
+    /** Custom emotion detector (e.g., call edge-workers) */
+    detectEmotion?: (request: Request) => Promise<EmotionState | undefined>;
+    /** Custom user tier resolver (e.g., from database) */
+    resolveUserTier?: (userId: string) => Promise<UserTier>;
+    /** Additional context enrichment */
+    enrich?: (context: UserContext, request: Request) => Promise<UserContext>;
+}
+/**
+ * Extract UserContext from an HTTP request
+ */
+export declare function extractUserContext(request: Request, options?: ContextExtractorOptions): Promise<UserContext>;
+/**
+ * Create middleware for user context extraction
+ */
+export declare function createContextMiddleware(options?: ContextExtractorOptions): (request: Request) => Promise<UserContext>;
+/**
+ * Set context tracking cookies in response
+ */
+export declare function setContextCookies(response: Response, context: UserContext, currentPath: string): Response;
+/**
+ * Add speculation hints to response headers
+ */
+export declare function addSpeculationHeaders(response: Response, prefetch: string[], prerender: string[]): Response;

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

@@ -0,0 +1,248 @@
+/**
+ * ESI Control Components (React)
+ *
+ * Control flow, Zod validation, and Presence-aware collaborative ESI.
+ *
+ * @example
+ * ```tsx
+ * // Conditional rendering based on inference
+ * <ESI.If
+ *   prompt="Should we show a discount?"
+ *   schema={z.object({ show: z.boolean(), reason: z.string() })}
+ *   when={(r) => r.show}
+ * >
+ *   <DiscountBanner />
+ * </ESI.If>
+ *
+ * // Presence-aware collaborative content
+ * <ESI.Collaborative
+ *   schema={z.object({ summary: z.string(), highlights: z.array(z.string()) })}
+ * >
+ *   Summarize this for {presence.length} viewers with roles: {roles}
+ * </ESI.Collaborative>
+ *
+ * // Structured output with Zod
+ * <ESI.Structured
+ *   schema={z.object({
+ *     sentiment: z.enum(['positive', 'negative', 'neutral']),
+ *     topics: z.array(z.string()),
+ *   })}
+ * >
+ *   Analyze: {text}
+ * </ESI.Structured>
+ * ```
+ */
+import { type ReactNode, type JSX } from 'react';
+import type { ZodType, ZodTypeDef } from 'zod';
+import type { PresenceUser } from './types';
+import { type ESICondition } from './esi-control';
+export interface ESIStructuredProps<T> {
+    /** The prompt - can be children or explicit prop */
+    children?: ReactNode;
+    prompt?: string;
+    /** Zod schema for output validation */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Render function for validated data */
+    render?: (data: T, meta: {
+        cached: boolean;
+        latencyMs: number;
+    }) => ReactNode;
+    /** Fallback if validation fails */
+    fallback?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Retry on validation failure */
+    retryOnFail?: boolean;
+    /** Max retries */
+    maxRetries?: number;
+    /** Additional inference params */
+    temperature?: number;
+    maxTokens?: number;
+    cacheTtl?: number;
+    /** Callbacks */
+    onSuccess?: (data: T) => void;
+    onValidationError?: (errors: string[], rawOutput: string) => void;
+    onError?: (error: string) => void;
+    /** Class name */
+    className?: string;
+}
+export declare function ESIStructured<T>({ children, prompt, schema, render, fallback, loading, retryOnFail, maxRetries, temperature, maxTokens, cacheTtl, onSuccess, onValidationError, onError, className, }: ESIStructuredProps<T>): JSX.Element;
+export interface ESIIfProps<T> {
+    /** The prompt to evaluate */
+    children?: ReactNode;
+    prompt?: string;
+    /** Zod schema for the condition evaluation */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Condition function - if true, render `then` */
+    when: ESICondition<T>;
+    /** Content to render if condition is true */
+    then: ReactNode;
+    /** Content to render if condition is false */
+    else?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Additional params */
+    temperature?: number;
+    cacheTtl?: number;
+    /** Callbacks */
+    onEvaluate?: (result: T, conditionMet: boolean) => void;
+    /** Class name */
+    className?: string;
+}
+export declare function ESIIf<T>({ children, prompt, schema, when, then: thenContent, else: elseContent, loading, temperature, cacheTtl, onEvaluate, className, }: ESIIfProps<T>): JSX.Element | null;
+export interface ESICaseProps<T> {
+    /** Match condition */
+    match: ESICondition<T>;
+    /** Content to render if matched */
+    children: ReactNode;
+}
+export declare function ESICase<T>({ children }: ESICaseProps<T>): JSX.Element;
+export interface ESIDefaultProps {
+    children: ReactNode;
+}
+export declare function ESIDefault({ children }: ESIDefaultProps): JSX.Element;
+export interface ESIMatchProps<T> {
+    /** The prompt to evaluate */
+    children: ReactNode;
+    prompt?: string;
+    /** Zod schema */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Loading state */
+    loading?: ReactNode;
+    /** Additional params */
+    temperature?: number;
+    cacheTtl?: number;
+    /** Callback */
+    onMatch?: (data: T, matchedIndex: number) => void;
+    /** Class name */
+    className?: string;
+}
+export declare function ESIMatch<T>({ children, prompt, schema, loading, temperature, cacheTtl, onMatch, className, }: ESIMatchProps<T>): JSX.Element | null;
+export interface ESICollaborativeProps<T> {
+    /** Base prompt - presence info will be injected */
+    children?: ReactNode;
+    prompt?: string;
+    /** Zod schema for output */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Custom render function */
+    render?: (data: T, presence: PresenceUser[]) => ReactNode;
+    /** Fallback content */
+    fallback?: ReactNode;
+    /** Loading state */
+    loading?: ReactNode;
+    /** How to describe users in the prompt */
+    describeUsers?: (users: PresenceUser[]) => string;
+    /** Re-infer when presence changes */
+    reactToPresenceChange?: boolean;
+    /** Debounce time for presence changes (ms) */
+    presenceDebounce?: number;
+    /** Additional params */
+    temperature?: number;
+    maxTokens?: number;
+    cacheTtl?: number;
+    /** Callbacks */
+    onSuccess?: (data: T, presence: PresenceUser[]) => void;
+    /** Class name */
+    className?: string;
+}
+export declare function ESICollaborative<T>({ children, prompt, schema, render, fallback, loading, describeUsers, reactToPresenceChange, presenceDebounce, temperature, maxTokens, cacheTtl, onSuccess, className, }: ESICollaborativeProps<T>): JSX.Element;
+export interface ESIReflectProps<T> {
+    /** The prompt */
+    children?: ReactNode;
+    prompt?: string;
+    /** Schema must include a quality/confidence field */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Continue until this condition is met */
+    until: (result: T, iteration: number) => boolean;
+    /** Max iterations */
+    maxIterations?: number;
+    /** Custom render */
+    render?: (data: T, iterations: number) => ReactNode;
+    /** Show intermediate results */
+    showProgress?: boolean;
+    /** Fallback */
+    fallback?: ReactNode;
+    /** Loading */
+    loading?: ReactNode;
+    /** Callbacks */
+    onIteration?: (data: T, iteration: number) => void;
+    onComplete?: (data: T, totalIterations: number) => void;
+    /** Class name */
+    className?: string;
+}
+export declare function ESIReflect<T>({ children, prompt, schema, until, maxIterations, render, showProgress, fallback, loading, onIteration, onComplete, className, }: ESIReflectProps<T>): JSX.Element;
+export interface ESIOptimizeProps<T> {
+    /** The prompt */
+    children?: ReactNode;
+    prompt?: string;
+    /** Schema for output */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Quality criteria to optimize for */
+    criteria?: string[];
+    /** Target quality score (0-1) */
+    targetQuality?: number;
+    /** Max optimization rounds */
+    maxRounds?: number;
+    /** Only optimize when user is alone (no other presence) */
+    onlyWhenAlone?: boolean;
+    /** Custom render */
+    render?: (data: T, meta: OptimizeMeta) => ReactNode;
+    /** Fallback */
+    fallback?: ReactNode;
+    /** Loading */
+    loading?: ReactNode;
+    /** Callbacks */
+    onImprove?: (data: T, round: number, quality: number) => void;
+    onOptimized?: (data: T, totalRounds: number, finalQuality: number) => void;
+    /** Class name */
+    className?: string;
+}
+export interface OptimizeMeta {
+    rounds: number;
+    quality: number;
+    improvements: string[];
+    wasOptimized: boolean;
+}
+export declare function ESIOptimize<T>({ children, prompt, schema, criteria, targetQuality, maxRounds, onlyWhenAlone, render, fallback, loading, onImprove, onOptimized, className, }: ESIOptimizeProps<T>): JSX.Element;
+export interface ESIAutoProps<T> {
+    /** The prompt */
+    children?: ReactNode;
+    prompt?: string;
+    /** Schema for output */
+    schema: ZodType<T, ZodTypeDef, unknown>;
+    /** Custom render */
+    render?: (data: T, mode: 'collaborative' | 'optimized' | 'basic') => ReactNode;
+    /** Minimum users for collaborative mode */
+    collaborativeThreshold?: number;
+    /** Optimization settings */
+    optimizeSettings?: {
+        criteria?: string[];
+        targetQuality?: number;
+        maxRounds?: number;
+    };
+    /** Fallback */
+    fallback?: ReactNode;
+    /** Loading */
+    loading?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+/**
+ * ESI.Auto - Automatically selects the best mode:
+ * - Multiple users → Collaborative (presence-aware)
+ * - Single user → Optimize (self-improving)
+ * - 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 declare const ESIControl: {
+    Structured: typeof ESIStructured;
+    If: typeof ESIIf;
+    Match: typeof ESIMatch;
+    Case: typeof ESICase;
+    Default: typeof ESIDefault;
+    Collaborative: typeof ESICollaborative;
+    Reflect: typeof ESIReflect;
+    Optimize: typeof ESIOptimize;
+    Auto: typeof ESIAuto;
+};
+export default ESIControl;