@affectively/aeon-pages-runtime 0.1.0 → 0.3.1

package/dist/api-routes.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Aeon Pages API Routes
+ *
+ * Server-side route handling for API endpoints.
+ * Enables full-stack functionality without a separate backend.
+ */
+import type { AeonEnv, AeonContext, ApiRoute, ApiRouteMatch, ApiRouteModule, ApiRouteHandler, ExecutionContext } from './types';
+/**
+ * API Router - matches requests to registered API routes
+ */
+export declare class ApiRouter<E extends AeonEnv = AeonEnv> {
+    private routes;
+    /**
+     * Register an API route
+     */
+    register(pattern: string, module: ApiRouteModule<E>): void;
+    /**
+     * Register multiple routes from a route map
+     */
+    registerAll(routes: Record<string, ApiRouteModule<E>>): void;
+    /**
+     * Match a request to a route
+     */
+    match(request: Request): ApiRouteMatch | null;
+    /**
+     * Handle an API request
+     */
+    handle(request: Request, env: E, ctx: ExecutionContext): Promise<Response | null>;
+    /**
+     * Parse a route pattern into segments
+     */
+    private parsePattern;
+    /**
+     * Match path segments against route segments
+     */
+    private matchSegments;
+    /**
+     * Get the handler for a given HTTP method
+     */
+    private getHandler;
+    /**
+     * Get all registered routes (for debugging/introspection)
+     */
+    getRoutes(): ApiRoute[];
+}
+/**
+ * Create a new API router instance
+ */
+export declare function createApiRouter<E extends AeonEnv = AeonEnv>(): ApiRouter<E>;
+/**
+ * Helper to create a JSON response
+ */
+export declare function json<T>(data: T, init?: ResponseInit): Response;
+/**
+ * Helper to create a redirect response
+ */
+export declare function redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+/**
+ * Helper to create an error response
+ */
+export declare function error(message: string, status?: number): Response;
+/**
+ * Helper to create a not found response
+ */
+export declare function notFound(message?: string): Response;
+/**
+ * Helper to create a bad request response
+ */
+export declare function badRequest(message?: string): Response;
+/**
+ * Helper to create an unauthorized response
+ */
+export declare function unauthorized(message?: string): Response;
+/**
+ * Helper to create a forbidden response
+ */
+export declare function forbidden(message?: string): Response;
+/** Middleware function type */
+export type Middleware<E extends AeonEnv = AeonEnv> = (context: AeonContext<E>, next: () => Promise<Response>) => Response | Promise<Response>;
+/**
+ * Compose multiple middleware into a single handler
+ */
+export declare function composeMiddleware<E extends AeonEnv = AeonEnv>(...middlewares: Middleware<E>[]): (handler: ApiRouteHandler<E>) => ApiRouteHandler<E>;
+/**
+ * CORS middleware factory
+ */
+export declare function cors(options?: {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    headers?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}): Middleware;
+/**
+ * Auth middleware factory - validates Authorization header
+ */
+export declare function requireAuth<E extends AeonEnv = AeonEnv>(validate: (token: string, context: AeonContext<E>) => boolean | Promise<boolean>): Middleware<E>;
+/**
+ * Rate limiting middleware (uses KV for distributed rate limiting)
+ */
+export declare function rateLimit<E extends AeonEnv = AeonEnv>(options: {
+    /** KV namespace key in env */
+    kvKey?: keyof E;
+    /** Requests per window */
+    limit: number;
+    /** Window size in seconds */
+    window: number;
+    /** Function to extract client identifier (default: IP) */
+    keyGenerator?: (context: AeonContext<E>) => string;
+}): Middleware<E>;

package/dist/benchmark.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Aeon Flux Benchmarks
+ *
+ * Run: bun run src/benchmark.ts
+ */
+export {};

package/dist/cache.d.ts

@@ -92,3 +92,80 @@ export declare class NavigationCache {
 }
 export declare function getNavigationCache(): NavigationCache;
 export declare function setNavigationCache(cache: NavigationCache): void;
+/** Cached skeleton data for a route */
+export interface CachedSkeleton {
+    route: string;
+    html: string;
+    css: string;
+    cachedAt: number;
+    expiresAt?: number;
+}
+/** Skeleton cache options */
+export interface SkeletonCacheOptions {
+    /** Maximum number of skeletons to cache */
+    maxSize?: number;
+    /** Default TTL in milliseconds */
+    defaultTtl?: number;
+}
+/**
+ * Skeleton Cache - Optimized for instant skeleton delivery
+ *
+ * Skeletons are cached separately from full pages for faster access.
+ * In edge environments, skeletons are stored in KV for ~1ms access.
+ */
+export declare class SkeletonCache {
+    private cache;
+    private maxSize;
+    private defaultTtl;
+    constructor(options?: SkeletonCacheOptions);
+    /**
+     * Get skeleton for a route
+     */
+    get(route: string): CachedSkeleton | null;
+    /**
+     * Store skeleton for a route
+     */
+    set(skeleton: CachedSkeleton, ttl?: number): void;
+    /**
+     * Check if skeleton is cached
+     */
+    has(route: string): boolean;
+    /**
+     * Invalidate skeleton for a route
+     */
+    invalidate(route: string): void;
+    /**
+     * Clear all cached skeletons
+     */
+    clear(): void;
+    /**
+     * Get cache size
+     */
+    get size(): number;
+    /**
+     * Export all skeletons for service worker
+     */
+    export(): CachedSkeleton[];
+    /**
+     * Import skeletons from service worker
+     */
+    import(skeletons: CachedSkeleton[]): void;
+}
+/** Skeleton and content result for progressive rendering */
+export interface SkeletonWithContent {
+    /** Skeleton HTML (available immediately) */
+    skeleton: CachedSkeleton | null;
+    /** Content promise (resolves later) */
+    content: Promise<CachedSession | null>;
+}
+/**
+ * Get skeleton and content in parallel for optimal UX
+ *
+ * @param route - The route to fetch
+ * @param skeletonCache - Skeleton cache instance
+ * @param sessionCache - Session cache instance
+ * @param contentFetcher - Function to fetch full content
+ */
+export declare function getWithSkeleton(route: string, skeletonCache: SkeletonCache, sessionCache: NavigationCache, contentFetcher: (route: string) => Promise<CachedSession>): SkeletonWithContent;
+export declare function getSkeletonCache(): SkeletonCache;
+export declare function setSkeletonCache(cache: SkeletonCache): void;

package/dist/durable-object.d.ts

@@ -11,6 +11,14 @@
  */
 interface Env {
     DB?: D1Database;
+    GITHUB_TOKEN?: string;
+    GITHUB_REPO?: string;
+    GITHUB_TREE_PATH?: string;
+    GITHUB_BASE_BRANCH?: string;
+    GITHUB_DEV_BRANCH?: string;
+    GITHUB_AUTO_MERGE?: string;
+    GITHUB_WEBHOOK_SECRET?: string;
+    SYNC_WEBHOOK_URL?: string;
 }
 interface D1Database {
     prepare(query: string): D1PreparedStatement;
@@ -33,6 +41,7 @@ export declare class AeonPageSession {
     private env;
     private sessions;
     private session;
+    private webhooks;
     constructor(state: DurableObjectState, env: Env);
     fetch(request: Request): Promise<Response>;
     private handleWebSocket;
@@ -40,11 +49,64 @@ export declare class AeonPageSession {
     private broadcast;
     private applyEdit;
     private propagateToD1;
+    /**
+     * Create a GitHub PR when tree changes
+     */
+    private createTreePR;
+    /**
+     * Merge a GitHub PR
+     */
+    private mergePR;
+    /**
+     * Handle GitHub webhook callbacks (push events)
+     * This is called when GitHub pushes changes to the repo
+     */
+    private handleWebhookEndpoint;
+    /**
+     * Verify GitHub webhook signature
+     */
+    private verifyGitHubSignature;
+    /**
+     * Process GitHub webhook events
+     */
+    private processGitHubWebhook;
+    /**
+     * Handle webhook configuration (register/list)
+     */
+    private handleWebhooksConfig;
+    /**
+     * Handle version request
+     */
+    private handleVersionRequest;
+    /**
+     * Fire webhooks for an event
+     */
+    private fireWebhook;
     private handleSessionRequest;
+    /**
+     * Handle session initialization (POST /init)
+     * Creates a new session or returns existing one
+     */
+    private handleInitRequest;
     private handleTreeRequest;
     private handlePresenceRequest;
     private getSession;
     private saveSession;
+    /**
+     * Handle sync queue batch (POST /sync-queue)
+     * Receives a batch of offline operations to sync
+     */
+    private handleSyncQueueRequest;
+    /**
+     * Handle queue status request (GET /queue-status)
+     * Returns pending operations for this session
+     */
+    private handleQueueStatusRequest;
+    /**
+     * Handle conflict resolution (POST /resolve-conflict)
+     * Manually resolve a detected conflict
+     */
+    private handleResolveConflictRequest;
 }
 /**
  * Aeon Routes Registry Durable Object
@@ -64,6 +126,7 @@ interface DurableObjectState {
     storage: DurableObjectStorage;
     id: DurableObjectId;
     waitUntil(promise: Promise<unknown>): void;
+    blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
 }
 interface DurableObjectStorage {
     get<T = unknown>(key: string): Promise<T | undefined>;

package/dist/index.d.ts

@@ -25,15 +25,31 @@ 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 type { NavigationOptions, PrefetchOptions, NavigationState, PresenceInfo as RoutePresenceInfo, } from './navigation';
+export { NavigationCache, getNavigationCache, setNavigationCache, SkeletonCache, getSkeletonCache, setSkeletonCache, getWithSkeleton, } from './cache';
+export type { CachedSession, CacheStats, NavigationCacheOptions, CachedSkeleton, SkeletonCacheOptions, SkeletonWithContent, } from './cache';
+export { initSkeleton, swapToContent, isSkeletonVisible, generateSkeletonInitScript, generateSkeletonPageStructure, generateAsyncSwapScript, } from './skeleton-hydrate';
+export type { SkeletonSwapOptions } from './skeleton-hydrate';
 export { NavigationPredictor, getPredictor, setPredictor, } from './predictor';
 export type { PredictedRoute, NavigationRecord, CommunityPattern, PredictorConfig, } from './predictor';
+export { SpeculativeRenderer, getSpeculativeRenderer, setSpeculativeRenderer, initSpeculativeRendering, } from './speculation';
+export type { PreRenderedPage, SpeculativeRendererConfig, } from './speculation';
 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 { ApiRouter, createApiRouter, json, redirect, error, notFound, badRequest, unauthorized, forbidden, composeMiddleware, cors, requireAuth, rateLimit, } from './api-routes';
+export type { Middleware } from './api-routes';
+export { createAeonWorker } from './worker';
+export type { AeonWorkerOptions } from './worker';
+export { adaptRequest, adaptHandler, adaptRouteModule, NextResponse, } from './nextjs-adapter';
+export type { NextRequest, NextRouteHandler, NextRouteModule, } from './nextjs-adapter';
+export type { OperationType, OperationPriority, OperationStatus, OfflineOperation, EncryptedQueueConfig, QueueStats, EncryptedPayload, EncryptionKeyMaterial, SyncBatch, SyncResult, ConflictDetectionResult, ResolutionStrategy, StoredConflict, NetworkState, BandwidthProfile, NetworkStateEvent, SyncCoordinatorConfig, SyncProgressEvent, OfflineQueueEvents, SyncCoordinatorEvents, } from './offline/types';
+export { OfflineOperationEncryption, getOperationEncryption, resetOperationEncryption, generateOperationId, estimateEncryptedSize, } from './offline/encryption';
+export { EncryptedOfflineQueue, getOfflineQueue, createOfflineQueue, resetOfflineQueue, } from './offline/encrypted-queue';
+export { ConflictResolver, getConflictResolver, createConflictResolver, resetConflictResolver, type ConflictResolverConfig, type ConflictStats as ConflictResolverStats, } from './sync/conflict-resolver';
+export { SyncCoordinator, getSyncCoordinator, createSyncCoordinator, resetSyncCoordinator, type SyncStats, } from './sync/coordinator';
+export { handlePush, handleNotificationClick, handleNotificationClose, handleSync, handleMessage, registerPushHandlers, registerSyncHandlers, registerMessageHandlers, urlBase64ToUint8Array, serializePushSubscription, type PushNotificationData, type PushHandlerConfig, type ServiceWorkerMessage, } from './service-worker-push';
+export type { AeonConfig, AeonOptions, SyncOptions, VersioningOptions, PresenceOptions, OfflineOptions, PushOptions, InstallOptions, SkeletonOptions, ComponentOptions, OutputOptions, RouteDefinition, RouteMatch, RouteMetadata, RouteOperation, SerializedComponent, PageSession, PresenceInfo, PresenceUser, AeonCapability, SkeletonShape, SkeletonSource, SkeletonDimensions, SkeletonMetadata, SkeletonHint, HttpMethod, AeonEnv, AeonContext, ExecutionContext, ApiRouteHandler, ApiRouteModule, ApiRoute, ApiRouteMatch, ApiRouteSegment, ServerRouteModule, ServerLoaderResult, ServerActionResult, D1Database, D1PreparedStatement, D1Result, D1ExecResult, KVNamespace, DurableObjectNamespace, DurableObjectId, DurableObjectStub, Ai, } 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";
+export declare const VERSION = "1.0.0";