@affectively/aeon-pages-runtime 0.1.0 → 0.3.1

package/dist/speculation.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Aeon Speculative Pre-Rendering
+ *
+ * Pre-renders pages before user clicks based on:
+ * 1. NavigationPredictor predictions (Markov chain, community patterns)
+ * 2. Link visibility (IntersectionObserver)
+ * 3. Hover intent signals
+ * 4. Browser Speculation Rules API (when available)
+ *
+ * This enables zero-latency navigation by having the page ready in memory.
+ */
+export interface PreRenderedPage {
+    route: string;
+    html: string;
+    prefetchedAt: number;
+    confidence: number;
+    stale: boolean;
+    size: number;
+}
+export interface SpeculativeRendererConfig {
+    /** Maximum pages to keep in memory cache */
+    maxCachedPages: number;
+    /** Maximum total size in bytes for cache */
+    maxCacheSize: number;
+    /** Time before a cached page is considered stale (ms) */
+    staleTTL: number;
+    /** Minimum confidence threshold to pre-render */
+    minConfidence: number;
+    /** Root margin for IntersectionObserver */
+    intersectionRootMargin: string;
+    /** Whether to use browser's Speculation Rules API */
+    useSpeculationRules: boolean;
+    /** Whether to pre-render on hover */
+    prerenderOnHover: boolean;
+    /** Hover delay before pre-rendering (ms) */
+    hoverDelay: number;
+    /** Base URL for session fetches */
+    sessionBaseUrl: string;
+}
+export declare class SpeculativeRenderer {
+    private config;
+    private cache;
+    private currentCacheSize;
+    private observer;
+    private hoverTimeouts;
+    private initialized;
+    constructor(config?: Partial<SpeculativeRendererConfig>);
+    /**
+     * Initialize the speculative renderer
+     * Call this after the page has loaded
+     */
+    init(): void;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+    /**
+     * Pre-render a specific route
+     */
+    prerender(route: string, confidence?: number): Promise<boolean>;
+    /**
+     * Navigate to a route using pre-rendered content if available
+     * Returns true if handled, false if fallback to normal navigation
+     */
+    navigate(route: string): Promise<boolean>;
+    /**
+     * Invalidate cached pages
+     */
+    invalidate(routes?: string[]): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        cachedPages: number;
+        cacheSize: number;
+        cacheHitRate: number;
+    };
+    private setupIntersectionObserver;
+    private observeLinks;
+    private onLinksVisible;
+    private setupHoverListeners;
+    private onLinkHover;
+    private onLinkLeave;
+    private injectSpeculationRules;
+    private setupNavigationInterception;
+    private startPredictivePrerendering;
+    private reinitialize;
+    private evictIfNeeded;
+}
+export declare function getSpeculativeRenderer(): SpeculativeRenderer;
+export declare function setSpeculativeRenderer(renderer: SpeculativeRenderer): void;
+/**
+ * Initialize speculative rendering (call on page load)
+ */
+export declare function initSpeculativeRendering(config?: Partial<SpeculativeRendererConfig>): SpeculativeRenderer;

package/dist/sync/conflict-resolver.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Aeon Pages Conflict Resolver
+ *
+ * Handles conflict detection and resolution for offline-first applications.
+ * Optimized for edge environments with configurable resolution strategies.
+ *
+ * Features:
+ * - Multiple resolution strategies (local-wins, remote-wins, merge, last-modified)
+ * - Automatic resolution for low-severity conflicts
+ * - Manual resolution queue for high-severity conflicts
+ * - Conflict statistics and history
+ */
+import type { OfflineOperation, StoredConflict, ResolutionStrategy } from '../offline/types';
+export interface ConflictResolverConfig {
+    /** Default resolution strategy */
+    defaultStrategy: ResolutionStrategy;
+    /** Enable automatic merging for similar updates */
+    enableAutoMerge: boolean;
+    /** Enable local-wins fallback */
+    enableLocalWins: boolean;
+    /** Maximum conflicts to cache */
+    maxConflictCacheSize: number;
+    /** Conflict resolution timeout in ms */
+    conflictTimeoutMs: number;
+    /** Similarity threshold (0-100) for auto-merge */
+    mergeThreshold: number;
+}
+export interface ConflictStats {
+    totalConflicts: number;
+    resolvedConflicts: number;
+    unresolvedConflicts: number;
+    conflictsByType: {
+        'update_update': number;
+        'delete_update': number;
+        'update_delete': number;
+        'concurrent': number;
+    };
+    resolutionsByStrategy: {
+        'local-wins': number;
+        'remote-wins': number;
+        'merge': number;
+        'manual': number;
+        'last-modified': number;
+    };
+    averageResolutionTimeMs: number;
+}
+type EventHandler<T> = (data: T) => void;
+declare class EventEmitter<Events extends Record<string, unknown> = Record<string, unknown>> {
+    private handlers;
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void;
+    off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void;
+    emit<K extends keyof Events>(event: K, data?: Events[K]): void;
+}
+export declare class ConflictResolver extends EventEmitter<{
+    'conflict:detected': StoredConflict;
+    'conflict:resolved': {
+        conflict: StoredConflict;
+        strategy: ResolutionStrategy;
+    };
+    'config:updated': ConflictResolverConfig;
+}> {
+    private conflicts;
+    private conflictsByEntity;
+    private config;
+    private resolutionTimings;
+    private stats;
+    constructor(config?: Partial<ConflictResolverConfig>);
+    /**
+     * Detect conflicts between local and remote operations
+     */
+    detectConflict(localOp: OfflineOperation, remoteOp: OfflineOperation): StoredConflict | null;
+    /**
+     * Calculate conflict severity
+     */
+    private calculateSeverity;
+    /**
+     * Calculate data similarity (0-100)
+     */
+    private calculateDataSimilarity;
+    /**
+     * Find conflicting fields between two data objects
+     */
+    private findConflictingFields;
+    /**
+     * Determine if conflict should auto-resolve
+     */
+    private shouldAutoResolve;
+    /**
+     * Resolve a conflict using specified strategy
+     */
+    resolveConflict(conflictId: string, strategy?: ResolutionStrategy): StoredConflict['resolution'] | null;
+    /**
+     * Attempt to merge conflicting data
+     */
+    private attemptMerge;
+    /**
+     * Get conflict by ID
+     */
+    getConflict(conflictId: string): StoredConflict | undefined;
+    /**
+     * Get all unresolved conflicts
+     */
+    getUnresolvedConflicts(): StoredConflict[];
+    /**
+     * Get conflicts for a session
+     */
+    getConflictsForSession(sessionId: string): StoredConflict[];
+    /**
+     * Get high severity unresolved conflicts
+     */
+    getHighSeverityConflicts(): StoredConflict[];
+    /**
+     * Get statistics
+     */
+    getStats(): ConflictStats;
+    /**
+     * Configure resolver
+     */
+    configure(config: Partial<ConflictResolverConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): ConflictResolverConfig;
+    /**
+     * Clear all conflicts
+     */
+    clear(): void;
+    /**
+     * Reset service (for testing)
+     */
+    reset(): void;
+}
+/**
+ * Get the singleton conflict resolver instance
+ */
+export declare function getConflictResolver(): ConflictResolver;
+/**
+ * Create a new conflict resolver with custom configuration
+ */
+export declare function createConflictResolver(config?: Partial<ConflictResolverConfig>): ConflictResolver;
+/**
+ * Reset the singleton resolver (for testing)
+ */
+export declare function resetConflictResolver(): void;
+export {};

package/dist/sync/coordinator.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Aeon Pages Sync Coordinator
+ *
+ * Coordinates synchronization of offline operations with server.
+ * Handles bandwidth optimization, batching, and network state management.
+ *
+ * Features:
+ * - Adaptive batch sizing based on network conditions
+ * - Network state tracking and monitoring
+ * - Bandwidth profiling
+ * - Sync progress tracking
+ * - Configurable compression and delta sync
+ */
+import type { OfflineOperation, SyncBatch, SyncResult, SyncCoordinatorConfig, SyncProgressEvent, NetworkState, NetworkStateEvent, BandwidthProfile } from '../offline/types';
+export interface SyncStats {
+    totalSyncsAttempted: number;
+    successfulSyncs: number;
+    failedSyncs: number;
+    totalOperationsSynced: number;
+    averageSyncDurationMs: number;
+    lastSyncTime?: number;
+    networkStateHistory: Array<{
+        state: NetworkState;
+        timestamp: number;
+    }>;
+    bandwidthHistory: BandwidthProfile[];
+}
+type EventHandler<T> = (data: T) => void;
+declare class EventEmitter<Events extends Record<string, unknown> = Record<string, unknown>> {
+    private handlers;
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void;
+    off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void;
+    emit<K extends keyof Events>(event: K, data?: Events[K]): void;
+}
+export declare class SyncCoordinator extends EventEmitter<{
+    'network:changed': NetworkStateEvent;
+    'network:online': void;
+    'network:offline': void;
+    'bandwidth:updated': BandwidthProfile;
+    'batch:created': SyncBatch;
+    'batch:started': {
+        batchId: string;
+    };
+    'batch:progress': SyncProgressEvent;
+    'batch:completed': {
+        batch: SyncBatch;
+        result: SyncResult;
+    };
+    'batch:failed': {
+        batch: SyncBatch;
+        error: string;
+    };
+    'batch:retry': {
+        batch: SyncBatch;
+        attempt: number;
+    };
+    'config:updated': SyncCoordinatorConfig;
+}> {
+    private networkState;
+    private bandwidthProfile;
+    private batches;
+    private progress;
+    private currentSyncBatchId;
+    private config;
+    private syncTimings;
+    private stats;
+    constructor(config?: Partial<SyncCoordinatorConfig>);
+    /**
+     * Initialize network state detection
+     */
+    private initNetworkDetection;
+    /**
+     * Update bandwidth profile from Network Information API
+     */
+    private updateBandwidthFromConnection;
+    /**
+     * Update network state
+     */
+    setNetworkState(state: NetworkState): void;
+    /**
+     * Get current network state
+     */
+    getNetworkState(): NetworkState;
+    /**
+     * Update bandwidth profile
+     */
+    updateBandwidthProfile(profile: Partial<BandwidthProfile>): void;
+    /**
+     * Get current bandwidth profile
+     */
+    getBandwidthProfile(): BandwidthProfile;
+    /**
+     * Create a sync batch from operations
+     */
+    createSyncBatch(operations: OfflineOperation[]): SyncBatch;
+    /**
+     * Start syncing a batch
+     */
+    startSyncBatch(batchId: string): void;
+    /**
+     * Update sync progress
+     */
+    updateProgress(batchId: string, syncedOperations: number, bytesSynced: number): void;
+    /**
+     * Complete a sync batch
+     */
+    completeSyncBatch(batchId: string, result: SyncResult): void;
+    /**
+     * Mark batch as failed
+     */
+    failSyncBatch(batchId: string, error: string, retryable?: boolean): void;
+    /**
+     * Get batch by ID
+     */
+    getBatch(batchId: string): SyncBatch | undefined;
+    /**
+     * Get all pending batches
+     */
+    getPendingBatches(): SyncBatch[];
+    /**
+     * Get current sync progress
+     */
+    getCurrentProgress(): SyncProgressEvent | undefined;
+    /**
+     * Estimate sync time for given bytes
+     */
+    estimateSyncTime(bytes: number): number;
+    /**
+     * Adapt batch sizes based on bandwidth
+     */
+    private adaptBatchSizes;
+    /**
+     * Get sync statistics
+     */
+    getStats(): SyncStats;
+    /**
+     * Configure the coordinator
+     */
+    configure(config: Partial<SyncCoordinatorConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SyncCoordinatorConfig;
+    /**
+     * Clear all batches
+     */
+    clear(): void;
+    /**
+     * Reset service (for testing)
+     */
+    reset(): void;
+}
+/**
+ * Get the singleton sync coordinator instance
+ */
+export declare function getSyncCoordinator(): SyncCoordinator;
+/**
+ * Create a new sync coordinator with custom configuration
+ */
+export declare function createSyncCoordinator(config?: Partial<SyncCoordinatorConfig>): SyncCoordinator;
+/**
+ * Reset the singleton coordinator (for testing)
+ */
+export declare function resetSyncCoordinator(): void;
+export {};

package/dist/tree-compiler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tree → TSX Compiler
+ *
+ * Converts component trees from the visual editor back to TSX source code.
+ */
+interface TreeNode {
+    id: string;
+    type: string;
+    props?: Record<string, unknown>;
+    children?: string[] | TreeNode[];
+    text?: string;
+}
+interface CompilerOptions {
+    /** Route path for the page */
+    route: string;
+    /** Include 'use aeon' directive */
+    useAeon?: boolean;
+    /** Component imports to add */
+    imports?: Record<string, string>;
+    /** Whether to format output */
+    format?: boolean;
+}
+/**
+ * Compile a tree to TSX source code
+ */
+export declare function compileTreeToTSX(tree: TreeNode | TreeNode[], options: CompilerOptions): string;
+export {};