@affectively/aeon-pages-runtime 0.1.0

package/dist/cache.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Navigation Cache - In-memory cache for total preload navigation
+ *
+ * With 8.4KB framework + ~2-5KB per page session, we can preload EVERYTHING.
+ * Site with 100 pages = ~315KB total (smaller than one hero image!)
+ */
+export interface CachedSession {
+    sessionId: string;
+    route: string;
+    tree: unknown;
+    data: Record<string, unknown>;
+    schemaVersion: string;
+    cachedAt: number;
+    expiresAt?: number;
+}
+export interface CacheStats {
+    size: number;
+    totalBytes: number;
+    hitRate: number;
+    preloadedRoutes: number;
+}
+export interface NavigationCacheOptions {
+    maxSize?: number;
+    defaultTtl?: number;
+    onEvict?: (session: CachedSession) => void;
+}
+export declare class NavigationCache {
+    private cache;
+    private accessOrder;
+    private hits;
+    private misses;
+    private maxSize;
+    private defaultTtl;
+    private onEvict?;
+    constructor(options?: NavigationCacheOptions);
+    /**
+     * Get a session from cache
+     */
+    get(sessionId: string): CachedSession | null;
+    /**
+     * Store a session in cache
+     */
+    set(session: CachedSession, ttl?: number): void;
+    /**
+     * Check if session is cached
+     */
+    has(sessionId: string): boolean;
+    /**
+     * Prefetch a session by ID
+     */
+    prefetch(sessionId: string, fetcher: () => Promise<CachedSession>): Promise<CachedSession>;
+    /**
+     * Prefetch multiple sessions in parallel
+     */
+    prefetchMany(sessionIds: string[], fetcher: (sessionId: string) => Promise<CachedSession>): Promise<CachedSession[]>;
+    /**
+     * Preload all sessions (total preload strategy)
+     */
+    preloadAll(manifest: {
+        sessionId: string;
+        route: string;
+    }[], fetcher: (sessionId: string) => Promise<CachedSession>, options?: {
+        onProgress?: (loaded: number, total: number) => void;
+    }): Promise<void>;
+    /**
+     * Invalidate a cached session
+     */
+    invalidate(sessionId: string): void;
+    /**
+     * Clear all cached sessions
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all cached session IDs
+     */
+    keys(): string[];
+    /**
+     * Export cache for service worker storage
+     */
+    export(): CachedSession[];
+    /**
+     * Import cache from service worker storage
+     */
+    import(sessions: CachedSession[]): void;
+    private evictLRU;
+    private updateAccessOrder;
+    private removeFromAccessOrder;
+}
+export declare function getNavigationCache(): NavigationCache;
+export declare function setNavigationCache(cache: NavigationCache): void;

package/dist/durable-object.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Aeon Pages Durable Object
+ *
+ * This is the Cloudflare Durable Object that provides:
+ * - Strong consistency for page sessions
+ * - Real-time WebSocket connections for collaboration
+ * - Presence tracking across connected clients
+ * - CRDT-based conflict resolution
+ *
+ * Deploy this alongside your Cloudflare Worker.
+ */
+interface Env {
+    DB?: D1Database;
+}
+interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+}
+interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    run(): Promise<void>;
+}
+/**
+ * Aeon Page Session Durable Object
+ *
+ * One instance per page session, handles:
+ * - Session state (component tree, data)
+ * - Real-time presence
+ * - WebSocket connections
+ * - Collaborative editing
+ */
+export declare class AeonPageSession {
+    private state;
+    private env;
+    private sessions;
+    private session;
+    constructor(state: DurableObjectState, env: Env);
+    fetch(request: Request): Promise<Response>;
+    private handleWebSocket;
+    private handleMessage;
+    private broadcast;
+    private applyEdit;
+    private propagateToD1;
+    private handleSessionRequest;
+    private handleTreeRequest;
+    private handlePresenceRequest;
+    private getSession;
+    private saveSession;
+}
+/**
+ * Aeon Routes Registry Durable Object
+ *
+ * Singleton that manages the route registry with strong consistency.
+ * Used via: namespace.idFromName('__routes__')
+ */
+export declare class AeonRoutesRegistry {
+    private state;
+    private env;
+    constructor(state: DurableObjectState, env: Env);
+    fetch(request: Request): Promise<Response>;
+    private handleRouteRequest;
+    private handleRoutesRequest;
+}
+interface DurableObjectState {
+    storage: DurableObjectStorage;
+    id: DurableObjectId;
+    waitUntil(promise: Promise<unknown>): void;
+}
+interface DurableObjectStorage {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    put<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    list<T = unknown>(options?: {
+        prefix?: string;
+    }): Promise<Map<string, T>>;
+}
+interface DurableObjectId {
+    toString(): string;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @affectively/aeon-pages-runtime
+ *
+ * Lightweight runtime for Aeon Pages - the CMS IS the website.
+ *
+ * @example
+ * ```typescript
+ * import { createAeonServer } from '@affectively/aeon-pages-runtime/server';
+ *
+ * const server = await createAeonServer({
+ *   config: {
+ *     pagesDir: './pages',
+ *     runtime: 'bun',
+ *     aeon: {
+ *       sync: { mode: 'distributed' },
+ *       presence: { enabled: true },
+ *     },
+ *   },
+ * });
+ *
+ * console.log(`Aeon Pages running on port ${server.port}`);
+ * ```
+ */
+export { createAeonServer } from './server';
+export { AeonRouter } from './router.js';
+export { AeonRouteRegistry } from './registry';
+export { AeonNavigationEngine, getNavigator, setNavigator, } from './navigation';
+export type { NavigationOptions, PrefetchOptions, NavigationState, } from './navigation';
+export { NavigationCache, getNavigationCache, setNavigationCache, } from './cache';
+export type { CachedSession, CacheStats, NavigationCacheOptions, } from './cache';
+export { NavigationPredictor, getPredictor, setPredictor, } from './predictor';
+export type { PredictedRoute, NavigationRecord, CommunityPattern, PredictorConfig, } from './predictor';
+export { createStorageAdapter, FileStorageAdapter, D1StorageAdapter, DurableObjectStorageAdapter, HybridStorageAdapter, DashStorageAdapter, } from './storage';
+export type { StorageAdapter } from './storage';
+export { AeonPageSession, AeonRoutesRegistry } from './durable-object';
+export type { AeonConfig, AeonOptions, SyncOptions, VersioningOptions, PresenceOptions, OfflineOptions, ComponentOptions, OutputOptions, RouteDefinition, RouteMatch, RouteMetadata, RouteOperation, SerializedComponent, PageSession, PresenceInfo, PresenceUser, AeonCapability, } from './types';
+export { DEFAULT_ROUTER_CONFIG, DEFAULT_ESI_CONFIG, HeuristicAdapter, EdgeWorkersESIProcessor, extractUserContext, createContextMiddleware, setContextCookies, addSpeculationHeaders, esiInfer, esiEmbed, esiEmotion, esiVision, esiWithContext, } from './router/index';
+export type { EmotionState, Viewport, ConnectionType, UserTier, UserContext, ThemeMode, LayoutDensity, LayoutType, SkeletonHints, RouteDecision, ComponentNode, ComponentTree, ComponentTreeSchema, RouterAdapter, HeuristicAdapterConfig, TierFeatures, SignalProcessor, ContextExtractorOptions, AIRouterConfig, SpeculationConfig, PersonalizationConfig, RouterConfig, RouterConfigWithESI, ESIModel, ESIContentType, ESIParams, ESIContent, ESIDirective, ESIResult, ESIProcessor, ESIConfig, } from './router/index';
+export declare const VERSION = "0.1.0";