@affectively/aeon-pages-runtime 0.1.0 → 0.3.0

package/dist/types.d.ts

@@ -28,6 +28,10 @@ export interface AeonOptions {
     presence?: PresenceOptions;
     /** Offline support configuration */
     offline?: OfflineOptions;
+    /** Push notification configuration */
+    push?: PushOptions;
+    /** PWA install prompt configuration */
+    install?: InstallOptions;
     /** Allow dynamic route creation for unclaimed paths */
     dynamicRoutes?: boolean;
 }
@@ -56,8 +60,55 @@ export interface PresenceOptions {
 export interface OfflineOptions {
     /** Enable offline support */
     enabled: boolean;
-    /** Maximum operations to queue offline */
+    /** Maximum operations to queue offline (default: 1000) */
     maxQueueSize?: number;
+    /** Encryption configuration for offline queue */
+    encryption?: {
+        /** Enable encryption for queued operations */
+        enabled: boolean;
+        /** Key derivation method: 'ucan' for UCAN-derived keys, 'session' for session-based */
+        keyDerivation?: 'ucan' | 'session';
+    };
+    /** Sync configuration */
+    sync?: {
+        /** Maximum operations per batch (default: 100) */
+        maxBatchSize?: number;
+        /** Maximum bytes per batch (default: 5MB) */
+        maxBatchBytes?: number;
+        /** Batch timeout in ms (default: 5000) */
+        batchTimeoutMs?: number;
+        /** Enable compression for batches (default: true) */
+        enableCompression?: boolean;
+        /** Enable delta sync (default: true) */
+        enableDeltaSync?: boolean;
+        /** Enable adaptive batch sizing based on network (default: true) */
+        adaptiveBatching?: boolean;
+    };
+    /** Storage configuration */
+    storage?: {
+        /** Maximum local storage capacity in bytes (default: 50MB) */
+        maxLocalCapacity?: number;
+        /** Interval for D1 sync in ms (default: 5 minutes) */
+        d1SyncInterval?: number;
+    };
+}
+/** Push notification configuration */
+export interface PushOptions {
+    /** Enable push notifications */
+    enabled: boolean;
+    /** VAPID public key for push subscription */
+    vapidPublicKey?: string;
+    /** Default notification icon */
+    defaultIcon?: string;
+    /** Default notification badge */
+    defaultBadge?: string;
+}
+/** PWA install prompt configuration */
+export interface InstallOptions {
+    /** Show install prompt when available */
+    showPrompt: boolean;
+    /** Show iOS-specific installation instructions */
+    iosInstructions: boolean;
 }
 export interface ComponentOptions {
     /** Auto-discover components from componentsDir */
@@ -113,11 +164,64 @@ export interface RouteOperation {
     timestamp: string;
     nodeId: string;
 }
+/** Shape types for skeleton rendering */
+export type SkeletonShape = 'rect' | 'circle' | 'text-line' | 'text-block' | 'container';
+/** Source of skeleton inference */
+export type SkeletonSource = 'tailwind' | 'prop-defaults' | 'hint' | 'measured';
+/** Skeleton dimensions extracted from Tailwind classes or props */
+export interface SkeletonDimensions {
+    /** Width CSS value: '256px', '100%', 'auto' */
+    width?: string;
+    /** Height CSS value: '48px', 'auto' */
+    height?: string;
+    /** Min height CSS value */
+    minHeight?: string;
+    /** Aspect ratio: '16/9', '1/1' */
+    aspectRatio?: string;
+    /** Padding CSS value */
+    padding?: string;
+    /** Margin CSS value */
+    margin?: string;
+    /** Border radius CSS value */
+    borderRadius?: string;
+    /** Gap for flex/grid containers */
+    gap?: string;
+}
+/** Skeleton metadata attached to component nodes */
+export interface SkeletonMetadata {
+    /** Computed dimensions from Tailwind/props/hints */
+    dimensions: SkeletonDimensions;
+    /** Shape hint for skeleton rendering */
+    shape: SkeletonShape;
+    /** Number of skeleton lines for text-block shape */
+    lines?: number;
+    /** Whether this node has dynamic content that needs skeleton */
+    isDynamic: boolean;
+    /** Confidence score (0-1) for inferred dimensions */
+    confidence: number;
+    /** Source of skeleton data */
+    source: SkeletonSource;
+}
+/** Skeleton hint parsed from data-skeleton-* attributes */
+export interface SkeletonHint {
+    /** Explicit shape override */
+    shape?: SkeletonShape;
+    /** Explicit width override */
+    width?: string;
+    /** Explicit height override */
+    height?: string;
+    /** Number of lines for text-block */
+    lines?: number;
+    /** Skip skeleton generation for this element */
+    ignore?: boolean;
+}
 /** Serialized component tree */
 export interface SerializedComponent {
     type: string;
     props?: Record<string, unknown>;
     children?: (SerializedComponent | string)[];
+    /** Skeleton metadata for zero-CLS rendering (computed at build time) */
+    _skeleton?: SkeletonMetadata;
 }
 /** Page session stored in Aeon */
 export interface PageSession {
@@ -133,6 +237,38 @@ export interface PageSession {
     };
     /** Active presence info */
     presence: PresenceInfo[];
+    /** Session version number (increments on each edit) */
+    version?: number;
+    /** Last modified timestamp */
+    updatedAt?: string;
+    /** Last modified by user/agent ID */
+    updatedBy?: string;
+}
+/** Webhook configuration for sync callbacks */
+export interface WebhookConfig {
+    /** URL to call when session changes */
+    url: string;
+    /** Secret for HMAC signature verification */
+    secret?: string;
+    /** Events to trigger webhook: 'edit', 'publish', 'all' */
+    events: ('edit' | 'publish' | 'merge' | 'all')[];
+}
+/** Webhook payload sent to callback URLs */
+export interface WebhookPayload {
+    /** Event type */
+    event: 'session.updated' | 'session.published' | 'session.merged' | 'github.push';
+    /** Session ID */
+    sessionId: string;
+    /** Route */
+    route: string;
+    /** Session version */
+    version: number;
+    /** Timestamp */
+    timestamp: string;
+    /** GitHub PR number (for publish/merge events) */
+    prNumber?: number;
+    /** User who triggered the event */
+    triggeredBy?: string;
 }
 /** Presence info for a user/agent */
 export interface PresenceInfo {
@@ -159,3 +295,188 @@ export interface AeonCapability {
 }
 /** Alias for PresenceInfo - used by react package */
 export type PresenceUser = PresenceInfo;
+/** HTTP methods supported for API routes */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/** Cloudflare Workers environment bindings */
+export interface AeonEnv {
+    /** Durable Object namespace for page sessions */
+    PAGE_SESSIONS?: DurableObjectNamespace;
+    /** Durable Object namespace for routes registry */
+    ROUTES_REGISTRY?: DurableObjectNamespace;
+    /** D1 Database binding */
+    DB?: D1Database;
+    /** Workers KV namespace for caching */
+    CACHE?: KVNamespace;
+    /** Workers AI binding */
+    AI?: Ai;
+    /** Environment name (development, staging, production) */
+    ENVIRONMENT?: string;
+    /** Allow additional custom bindings */
+    [key: string]: unknown;
+}
+/** D1 Database interface */
+export interface D1Database {
+    prepare(query: string): D1PreparedStatement;
+    exec(query: string): Promise<D1ExecResult>;
+    batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+    dump(): Promise<ArrayBuffer>;
+}
+export interface D1PreparedStatement {
+    bind(...values: unknown[]): D1PreparedStatement;
+    run(): Promise<D1Result>;
+    first<T = unknown>(colName?: string): Promise<T | null>;
+    all<T = unknown>(): Promise<D1Result<T>>;
+    raw<T = unknown>(): Promise<T[]>;
+}
+export interface D1Result<T = unknown> {
+    results?: T[];
+    success: boolean;
+    error?: string;
+    meta?: {
+        duration: number;
+        changes: number;
+        last_row_id: number;
+        served_by: string;
+    };
+}
+export interface D1ExecResult {
+    count: number;
+    duration: number;
+}
+/** KV Namespace interface */
+export interface KVNamespace {
+    get(key: string, options?: {
+        type?: 'text' | 'json' | 'arrayBuffer' | 'stream';
+    }): Promise<string | null>;
+    getWithMetadata<T = unknown>(key: string): Promise<{
+        value: string | null;
+        metadata: T | null;
+    }>;
+    put(key: string, value: string | ArrayBuffer | ReadableStream, options?: {
+        expirationTtl?: number;
+        metadata?: unknown;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        keys: {
+            name: string;
+        }[];
+        list_complete: boolean;
+        cursor?: string;
+    }>;
+}
+/** Durable Object Namespace interface */
+export interface DurableObjectNamespace {
+    idFromName(name: string): DurableObjectId;
+    idFromString(id: string): DurableObjectId;
+    newUniqueId(): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub;
+}
+export interface DurableObjectId {
+    toString(): string;
+    equals(other: DurableObjectId): boolean;
+}
+export interface DurableObjectStub {
+    fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+    id: DurableObjectId;
+}
+/** Workers AI interface */
+export interface Ai {
+    run<T = unknown>(model: string, inputs: unknown, options?: {
+        gateway?: {
+            id: string;
+        };
+    }): Promise<T>;
+}
+/** Context passed to API route handlers */
+export interface AeonContext<E extends AeonEnv = AeonEnv> {
+    /** The incoming request */
+    request: Request;
+    /** Environment bindings (D1, KV, AI, Durable Objects, etc.) */
+    env: E;
+    /** Extracted URL parameters from dynamic routes */
+    params: Record<string, string>;
+    /** The request URL parsed */
+    url: URL;
+    /** Execution context for waitUntil, etc. */
+    ctx: ExecutionContext;
+}
+/** Execution context for Cloudflare Workers */
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/** API route handler function */
+export type ApiRouteHandler<E extends AeonEnv = AeonEnv> = (context: AeonContext<E>) => Response | Promise<Response>;
+/** API route module - exports handlers for each HTTP method */
+export interface ApiRouteModule<E extends AeonEnv = AeonEnv> {
+    GET?: ApiRouteHandler<E>;
+    POST?: ApiRouteHandler<E>;
+    PUT?: ApiRouteHandler<E>;
+    PATCH?: ApiRouteHandler<E>;
+    DELETE?: ApiRouteHandler<E>;
+    HEAD?: ApiRouteHandler<E>;
+    OPTIONS?: ApiRouteHandler<E>;
+    /** Catch-all handler for any method */
+    default?: ApiRouteHandler<E>;
+}
+/** Registered API route */
+export interface ApiRoute {
+    /** Route pattern (e.g., "/api/chat", "/api/users/[id]") */
+    pattern: string;
+    /** Parsed path segments for matching */
+    segments: ApiRouteSegment[];
+    /** The route module with handlers */
+    module: ApiRouteModule;
+}
+/** Segment of an API route pattern */
+export interface ApiRouteSegment {
+    /** The segment text */
+    value: string;
+    /** Is this a dynamic parameter? */
+    isDynamic: boolean;
+    /** Is this a catch-all segment? */
+    isCatchAll: boolean;
+}
+/** API route match result */
+export interface ApiRouteMatch {
+    /** The matched route */
+    route: ApiRoute;
+    /** Extracted parameters */
+    params: Record<string, string>;
+    /** The handler for the request method */
+    handler: ApiRouteHandler;
+}
+/** Server route module - for page-level server logic */
+export interface ServerRouteModule<E extends AeonEnv = AeonEnv> {
+    /** Called before page render - can return data or redirect */
+    loader?: (context: AeonContext<E>) => Promise<ServerLoaderResult>;
+    /** Called on form submission or POST to the page */
+    action?: (context: AeonContext<E>) => Promise<ServerActionResult>;
+}
+/** Result from a server loader */
+export interface ServerLoaderResult {
+    /** Data to pass to the page */
+    data?: Record<string, unknown>;
+    /** Redirect to another URL */
+    redirect?: string;
+    /** Response status code */
+    status?: number;
+    /** Additional headers */
+    headers?: Record<string, string>;
+}
+/** Result from a server action */
+export interface ServerActionResult {
+    /** Data to return */
+    data?: Record<string, unknown>;
+    /** Errors to display */
+    errors?: Record<string, string>;
+    /** Redirect after action */
+    redirect?: string;
+    /** Response status code */
+    status?: number;
+}

package/dist/worker.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Aeon Pages Cloudflare Worker
+ *
+ * Entry point for Cloudflare Workers deployment.
+ * Handles routing to Durable Objects, API routes, and static assets.
+ */
+export { AeonPageSession, AeonRoutesRegistry } from './durable-object';
+import type { AeonEnv, ApiRouteModule, ExecutionContext } from './types';
+/** Options for creating an Aeon worker */
+export interface AeonWorkerOptions<E extends AeonEnv = AeonEnv> {
+    /** API routes to register */
+    apiRoutes?: Record<string, ApiRouteModule<E>>;
+    /** CORS configuration */
+    cors?: {
+        origin?: string | string[];
+        methods?: string[];
+        headers?: string[];
+        credentials?: boolean;
+    };
+    /** Custom fetch handler to run before Aeon routing */
+    onRequest?: (request: Request, env: E, ctx: ExecutionContext) => Promise<Response | null>;
+    /** Custom 404 handler */
+    notFound?: (request: Request, env: E) => Response | Promise<Response>;
+}
+/**
+ * Create an Aeon worker with API route support
+ *
+ * @example
+ * ```typescript
+ * import { createAeonWorker } from '@affectively/aeon-pages-runtime/worker';
+ *
+ * export default createAeonWorker({
+ *   apiRoutes: {
+ *     '/api/chat': {
+ *       POST: async ({ request, env }) => {
+ *         const body = await request.json();
+ *         const result = await env.AI.run('@cf/meta/llama-3-8b-instruct', { ... });
+ *         return Response.json({ result });
+ *       },
+ *     },
+ *     '/api/users/[id]': {
+ *       GET: async ({ params, env }) => {
+ *         const user = await env.DB.prepare('SELECT * FROM users WHERE id = ?')
+ *           .bind(params.id)
+ *           .first();
+ *         return Response.json(user);
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function createAeonWorker<E extends AeonEnv = AeonEnv>(options?: AeonWorkerOptions<E>): ExportedHandler<E>;
+/** Cloudflare Worker exported handler interface */
+interface ExportedHandler<E = unknown> {
+    fetch(request: Request, env: E, ctx: ExecutionContext): Promise<Response>;
+}
+declare const _default: ExportedHandler<AeonEnv>;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affectively/aeon-pages-runtime",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Bun/Cloudflare runtime for @affectively/aeon-pages",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,7 +23,14 @@
     "build": "bun build ./src/index.ts ./src/server.ts ./src/router/index.ts --outdir ./dist --target bun && tsc --declaration --emitDeclarationOnly",
     "dev": "bun --watch ./src/index.ts",
     "test": "bun test",
-    "prepublishOnly": "bun run build"
+    "prepublishOnly": "bun run build",
+    "deploy": "wrangler deploy",
+    "deploy:staging": "wrangler deploy --env staging",
+    "dev:worker": "wrangler dev",
+    "db:create": "wrangler d1 create aeon-pages",
+    "db:migrate": "wrangler d1 execute aeon-pages --file=./schema.sql",
+    "db:migrate:local": "wrangler d1 execute aeon-pages --local --file=./schema.sql",
+    "tail": "wrangler tail"
   },
   "files": [
     "dist",