@dotdo/do 0.1.0

package/dist/rpc/server.js

@@ -0,0 +1,850 @@
+/**
+ * CapnWeb RPC Server
+ *
+ * Handles both WebSocket and HTTP transports for RPC communication.
+ * Implements Cloudflare Durable Object WebSocket hibernation for 95% cost savings.
+ *
+ * @module rpc/server
+ *
+ * @example
+ * ```typescript
+ * import { RPCServer } from 'do/rpc/server'
+ * import { MethodRegistry } from 'do/rpc/methods'
+ *
+ * export class MyDurableObject {
+ *   private rpc: RPCServer
+ *
+ *   constructor(state: DurableObjectState, env: Env) {
+ *     const registry = new MethodRegistry()
+ *     // Register your methods...
+ *
+ *     this.rpc = new RPCServer(state, env, registry)
+ *   }
+ *
+ *   async fetch(request: Request): Promise<Response> {
+ *     return this.rpc.handleRequest(request)
+ *   }
+ *
+ *   // Hibernation handlers
+ *   async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
+ *     return this.rpc.handleWebSocketMessage(ws, message)
+ *   }
+ *
+ *   async webSocketClose(ws: WebSocket, code: number, reason: string) {
+ *     return this.rpc.handleWebSocketClose(ws, code, reason)
+ *   }
+ *
+ *   async webSocketError(ws: WebSocket, error: unknown) {
+ *     return this.rpc.handleWebSocketError(ws, error)
+ *   }
+ * }
+ * ```
+ */
+import { RpcErrorCodes as ErrorCodes } from '../types/rpc';
+export class RPCServer {
+    state;
+    env;
+    options;
+    connections;
+    wsToId;
+    methods;
+    rateLimitState;
+    /**
+     * Create a new RPC server
+     *
+     * @param options - Server configuration including state, env, and registry
+     */
+    constructor(options) {
+        this.options = options || {};
+        this.state = options?.state;
+        this.env = options?.env || {};
+        this.connections = new Map();
+        this.wsToId = new Map();
+        this.methods = new Map();
+        this.rateLimitState = new Map();
+    }
+    // ===========================================================================
+    // Request Handling
+    // ===========================================================================
+    /**
+     * Handle an incoming HTTP request
+     *
+     * Routes to appropriate handler based on method and path:
+     * - GET /rpc - Schema discovery
+     * - GET /rpc/* - Method documentation
+     * - POST / or POST /rpc - Execute RPC
+     * - WebSocket upgrade on /rpc
+     *
+     * @param request - Incoming HTTP request
+     * @returns HTTP response
+     *
+     * @example
+     * ```typescript
+     * async fetch(request: Request): Promise<Response> {
+     *   return this.rpc.handleRequest(request)
+     * }
+     * ```
+     */
+    async handleRequest(request) {
+        const url = new URL(request.url);
+        const path = url.pathname;
+        // Check for WebSocket upgrade
+        const upgradeHeader = request.headers.get('Upgrade');
+        if (upgradeHeader?.toLowerCase() === 'websocket') {
+            return this.handleWebSocketUpgrade(request);
+        }
+        // Handle CORS preflight
+        if (request.method === 'OPTIONS') {
+            return this.handleCors();
+        }
+        // GET returns method info
+        if (request.method === 'GET') {
+            const methodList = this.getMethods();
+            return this.addCorsHeaders(new Response(JSON.stringify({ methods: methodList }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }));
+        }
+        // POST / or POST /rpc - Execute RPC
+        if (request.method === 'POST' && (path === '/' || path === '/rpc')) {
+            return this.handleHttpRpc(request);
+        }
+        return new Response('Not Found', { status: 404 });
+    }
+    /**
+     * Handle WebSocket upgrade request
+     *
+     * Creates a WebSocket pair and accepts the connection.
+     * The connection will hibernate after the idle timeout.
+     *
+     * @param request - WebSocket upgrade request
+     * @returns Response with WebSocket
+     */
+    async handleWebSocketUpgrade(request) {
+        const pair = new WebSocketPair();
+        const [client, server] = [pair[0], pair[1]];
+        const connectionId = crypto.randomUUID();
+        const now = Date.now();
+        const connState = {
+            id: connectionId,
+            ws: server,
+            status: 'open',
+            connectedAt: now,
+            lastMessageAt: now,
+            subscriptions: [],
+            queuedEvents: [],
+        };
+        this.connections.set(connectionId, connState);
+        this.wsToId.set(server, connectionId);
+        // Set up idle timer if hibernation is enabled
+        this.setupIdleTimer(connectionId);
+        server.accept?.();
+        return new Response(null, {
+            status: 101,
+            webSocket: client,
+        });
+    }
+    /**
+     * Handle HTTP POST RPC request
+     *
+     * @param request - HTTP POST request with JSON body
+     * @returns JSON response with RPC result
+     */
+    async handleHttpRpc(request) {
+        // Set up timeout wrapper if configured
+        const doHttpRpc = async () => {
+            // Check Content-Type
+            const contentType = request.headers.get('Content-Type') || '';
+            if (!contentType.includes('application/json')) {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: null,
+                    error: { code: ErrorCodes.ParseError, message: 'Unsupported Media Type' },
+                }), { status: 415, headers: { 'Content-Type': 'application/json' } }));
+            }
+            // Check rate limit
+            if (this.options.rateLimit) {
+                const clientId = request.headers.get('CF-Connecting-IP') || 'default';
+                if (this.isRateLimited(clientId)) {
+                    return this.addCorsHeaders(new Response(JSON.stringify({
+                        id: null,
+                        error: { code: ErrorCodes.RateLimited, message: 'Rate limit exceeded' },
+                    }), { status: 429, headers: { 'Content-Type': 'application/json' } }));
+                }
+            }
+            let body;
+            try {
+                body = await request.text();
+            }
+            catch {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: null,
+                    error: { code: ErrorCodes.ParseError, message: 'Parse error: unable to read body' },
+                }), { status: 400, headers: { 'Content-Type': 'application/json' } }));
+            }
+            // Check payload size after reading body
+            if (this.options.maxPayloadSize && body.length > this.options.maxPayloadSize) {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: null,
+                    error: { code: ErrorCodes.InvalidRequest, message: 'Payload Too Large' },
+                }), { status: 413, headers: { 'Content-Type': 'application/json' } }));
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: null,
+                    error: { code: ErrorCodes.ParseError, message: 'Parse error: invalid JSON' },
+                }), { status: 400, headers: { 'Content-Type': 'application/json' } }));
+            }
+            // Check if batch request
+            if (this.isBatchRequest(parsed)) {
+                const batchReq = parsed;
+                const responses = [];
+                for (const req of batchReq.requests) {
+                    const response = await this.executeRequest(req);
+                    responses.push(response);
+                    if (batchReq.abortOnError && response.error) {
+                        break;
+                    }
+                }
+                const batchResponse = {
+                    id: batchReq.id,
+                    responses,
+                    success: !responses.some((r) => r.error),
+                };
+                return this.addCorsHeaders(new Response(JSON.stringify(batchResponse), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/json' },
+                }));
+            }
+            // Single request
+            const rpcRequest = parsed;
+            // Validate request structure
+            if (!rpcRequest.id) {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: null,
+                    error: { code: ErrorCodes.InvalidRequest, message: 'Invalid Request: missing id' },
+                }), { status: 400, headers: { 'Content-Type': 'application/json' } }));
+            }
+            if (!rpcRequest.method) {
+                return this.addCorsHeaders(new Response(JSON.stringify({
+                    id: rpcRequest.id,
+                    error: { code: ErrorCodes.InvalidRequest, message: 'Invalid Request: missing method' },
+                }), { status: 400, headers: { 'Content-Type': 'application/json' } }));
+            }
+            const response = await this.executeRequest(rpcRequest);
+            return this.addCorsHeaders(new Response(JSON.stringify(response), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }));
+        };
+        // If methodTimeout is set, race the entire operation against a timeout
+        if (this.options.methodTimeout) {
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve(this.addCorsHeaders(new Response(JSON.stringify({
+                        id: null,
+                        error: { code: ErrorCodes.Timeout, message: 'Method timeout' },
+                    }), { status: 200, headers: { 'Content-Type': 'application/json' } })));
+                }, this.options.methodTimeout);
+            });
+            return Promise.race([doHttpRpc(), timeoutPromise]);
+        }
+        return doHttpRpc();
+    }
+    // ===========================================================================
+    // WebSocket Hibernation Handlers
+    // ===========================================================================
+    /**
+     * Handle WebSocket message (hibernation callback)
+     *
+     * Called by Cloudflare when a message is received on a hibernated WebSocket.
+     *
+     * @param ws - WebSocket that received the message
+     * @param message - Message content (string or ArrayBuffer)
+     *
+     * @example
+     * ```typescript
+     * async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
+     *   return this.rpc.handleWebSocketMessage(ws, message)
+     * }
+     * ```
+     */
+    async handleWebSocketMessage(ws, message) {
+        const connectionId = this.wsToId.get(ws);
+        const connState = connectionId ? this.connections.get(connectionId) : undefined;
+        // Reset idle timer on activity
+        if (connectionId) {
+            this.resetIdleTimer(connectionId);
+        }
+        // Parse message
+        let parsed;
+        try {
+            const msgStr = typeof message === 'string' ? message : new TextDecoder().decode(message);
+            parsed = JSON.parse(msgStr);
+        }
+        catch {
+            const errorResponse = {
+                id: '',
+                error: { code: ErrorCodes.ParseError, message: 'Parse error: invalid JSON' },
+            };
+            ws.send(JSON.stringify(errorResponse));
+            return;
+        }
+        // Execute and respond
+        const response = await this.executeRequest(parsed, connState?.data);
+        ws.send(JSON.stringify(response));
+    }
+    /**
+     * Handle WebSocket close (hibernation callback)
+     *
+     * @param ws - WebSocket that was closed
+     * @param code - Close code
+     * @param reason - Close reason
+     */
+    async handleWebSocketClose(ws, code, reason) {
+        const connectionId = this.wsToId.get(ws);
+        if (connectionId) {
+            const connState = this.connections.get(connectionId);
+            if (connState) {
+                connState.status = 'closed';
+                if (connState.idleTimer)
+                    clearTimeout(connState.idleTimer);
+                if (connState.hibernationTimer)
+                    clearTimeout(connState.hibernationTimer);
+            }
+        }
+    }
+    /**
+     * Handle WebSocket error (hibernation callback)
+     *
+     * @param ws - WebSocket that errored
+     * @param error - Error that occurred
+     */
+    async handleWebSocketError(ws, error) {
+        const connectionId = this.wsToId.get(ws);
+        if (connectionId) {
+            const connState = this.connections.get(connectionId);
+            if (connState) {
+                connState.status = 'closed';
+                if (connState.idleTimer)
+                    clearTimeout(connState.idleTimer);
+                if (connState.hibernationTimer)
+                    clearTimeout(connState.hibernationTimer);
+            }
+        }
+    }
+    // ===========================================================================
+    // Connection Management
+    // ===========================================================================
+    /**
+     * Get all active WebSocket connections
+     *
+     * @returns Array of connection states
+     */
+    getConnections() {
+        return Array.from(this.connections.values()).map((c) => ({
+            id: c.id,
+            status: c.status,
+            connectedAt: c.connectedAt,
+            hibernatedAt: c.hibernatedAt,
+            lastMessageAt: c.lastMessageAt,
+            subscriptions: c.subscriptions,
+            data: c.data,
+        }));
+    }
+    /**
+     * Get a specific connection by ID
+     *
+     * @param id - Connection ID
+     * @returns Connection state or undefined
+     */
+    getConnection(id) {
+        const conn = this.connections.get(id);
+        if (!conn)
+            return undefined;
+        return {
+            id: conn.id,
+            status: conn.status,
+            connectedAt: conn.connectedAt,
+            hibernatedAt: conn.hibernatedAt,
+            lastMessageAt: conn.lastMessageAt,
+            subscriptions: conn.subscriptions,
+            data: conn.data,
+        };
+    }
+    /**
+     * Broadcast a message to all connected clients
+     *
+     * @param message - Message to broadcast
+     * @param filter - Optional filter function
+     */
+    async broadcast(message, filter) {
+        for (const conn of this.connections.values()) {
+            if (conn.status !== 'open')
+                continue;
+            const wsState = {
+                id: conn.id,
+                status: conn.status,
+                connectedAt: conn.connectedAt,
+                lastMessageAt: conn.lastMessageAt,
+                subscriptions: conn.subscriptions,
+                data: conn.data,
+            };
+            if (filter && !filter(wsState))
+                continue;
+            conn.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Send a message to a specific connection
+     *
+     * @param connectionId - Target connection ID
+     * @param message - Message to send
+     */
+    async send(connectionId, message) {
+        const conn = this.connections.get(connectionId);
+        if (conn && conn.status === 'open') {
+            conn.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Close a connection
+     *
+     * @param connectionId - Connection to close
+     * @param code - Close code
+     * @param reason - Close reason
+     */
+    async closeConnection(connectionId, code, reason) {
+        const conn = this.connections.get(connectionId);
+        if (conn) {
+            conn.ws.close(code, reason);
+            conn.status = 'closed';
+            if (conn.idleTimer)
+                clearTimeout(conn.idleTimer);
+            if (conn.hibernationTimer)
+                clearTimeout(conn.hibernationTimer);
+        }
+    }
+    // ===========================================================================
+    // Method Registration
+    // ===========================================================================
+    /**
+     * Register a method handler
+     *
+     * @param name - Method name (e.g., 'do.things.list')
+     * @param handler - Handler function
+     */
+    registerMethod(name, handler) {
+        this.methods.set(name, handler);
+    }
+    /**
+     * Unregister a method handler
+     *
+     * @param name - Method name to unregister
+     */
+    unregisterMethod(name) {
+        this.methods.delete(name);
+    }
+    /**
+     * Get all registered method names
+     *
+     * @returns Array of method names
+     */
+    getMethods() {
+        return Array.from(this.methods.keys());
+    }
+    // ===========================================================================
+    // Subscription and Events
+    // ===========================================================================
+    /**
+     * Subscribe a connection to a channel
+     *
+     * @param connectionId - Connection ID
+     * @param channel - Channel name
+     */
+    async subscribe(connectionId, channel) {
+        const conn = this.connections.get(connectionId);
+        if (conn && !conn.subscriptions.includes(channel)) {
+            conn.subscriptions.push(channel);
+        }
+    }
+    /**
+     * Emit an event to all subscribers of a channel
+     *
+     * @param channel - Channel name
+     * @param data - Event data
+     */
+    async emit(channel, data) {
+        for (const conn of this.connections.values()) {
+            if (!conn.subscriptions.includes(channel))
+                continue;
+            if (conn.status === 'hibernating') {
+                // Queue event for later delivery
+                conn.queuedEvents.push({ channel, data });
+            }
+            else if (conn.status === 'open') {
+                const event = {
+                    id: '',
+                    result: { channel, data },
+                };
+                conn.ws.send(JSON.stringify(event));
+            }
+        }
+    }
+    // ===========================================================================
+    // Connection Registration
+    // ===========================================================================
+    /**
+     * Register a connection
+     *
+     * @param connectionId - Unique connection ID
+     * @param ws - WebSocket instance
+     */
+    registerConnection(connectionId, ws) {
+        const now = Date.now();
+        const connState = {
+            id: connectionId,
+            ws,
+            status: 'open',
+            connectedAt: now,
+            lastMessageAt: now,
+            subscriptions: [],
+            queuedEvents: [],
+        };
+        this.connections.set(connectionId, connState);
+        this.wsToId.set(ws, connectionId);
+        this.setupIdleTimer(connectionId);
+    }
+    /**
+     * Set custom data for a connection
+     *
+     * @param connectionId - Connection ID
+     * @param data - Custom data to store
+     */
+    setConnectionData(connectionId, data) {
+        const conn = this.connections.get(connectionId);
+        if (conn) {
+            conn.data = data;
+        }
+    }
+    /**
+     * Wake a hibernated connection
+     *
+     * @param ws - WebSocket instance
+     * @returns Connection ID
+     */
+    async wakeConnection(ws) {
+        // Try to restore from attachment
+        let connectionId = this.wsToId.get(ws);
+        let restored;
+        try {
+            restored = ws.deserializeAttachment?.();
+        }
+        catch {
+            // Ignore
+        }
+        if (!connectionId) {
+            connectionId = crypto.randomUUID();
+        }
+        const existing = this.connections.get(connectionId);
+        if (existing) {
+            existing.status = 'open';
+            existing.hibernatedAt = undefined;
+            if (restored) {
+                existing.data = { ...existing.data, ...restored };
+            }
+            // Clear hibernation timer
+            if (existing.hibernationTimer) {
+                clearTimeout(existing.hibernationTimer);
+                existing.hibernationTimer = undefined;
+            }
+            // Deliver queued events
+            for (const event of existing.queuedEvents) {
+                const response = {
+                    id: '',
+                    result: { channel: event.channel, data: event.data },
+                };
+                ws.send(JSON.stringify(response));
+            }
+            existing.queuedEvents = [];
+            this.setupIdleTimer(connectionId);
+        }
+        else {
+            // New connection
+            const now = Date.now();
+            const connState = {
+                id: connectionId,
+                ws,
+                status: 'open',
+                connectedAt: now,
+                lastMessageAt: now,
+                subscriptions: [],
+                data: restored,
+                queuedEvents: [],
+            };
+            this.connections.set(connectionId, connState);
+            this.wsToId.set(ws, connectionId);
+            this.setupIdleTimer(connectionId);
+        }
+        return connectionId;
+    }
+    // ===========================================================================
+    // Fetch Handler
+    // ===========================================================================
+    /**
+     * Handle an incoming HTTP request (convenience method)
+     *
+     * Alias for handleRequest for Worker fetch handler compatibility.
+     *
+     * @param request - Incoming HTTP request
+     * @returns HTTP response
+     */
+    async fetch(request) {
+        return this.handleRequest(request);
+    }
+    // ===========================================================================
+    // Internal Helpers
+    // ===========================================================================
+    /**
+     * Build method context from request
+     *
+     * @param request - Optional HTTP request
+     * @param ws - Optional WebSocket
+     * @returns Method context
+     */
+    buildContext(request, ws, meta) {
+        return {
+            state: this.state,
+            env: this.env,
+            meta: meta,
+            websocket: ws,
+            request,
+        };
+    }
+    /**
+     * Handle CORS preflight request
+     *
+     * @returns CORS preflight response
+     */
+    handleCors() {
+        return new Response(null, {
+            status: 204,
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type',
+                'Access-Control-Max-Age': '86400',
+            },
+        });
+    }
+    /**
+     * Add CORS headers to response
+     *
+     * @param response - Response to modify
+     * @returns Response with CORS headers
+     */
+    addCorsHeaders(response) {
+        const newHeaders = new Headers(response.headers);
+        newHeaders.set('Access-Control-Allow-Origin', '*');
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    /**
+     * Check if a request is a batch request
+     */
+    isBatchRequest(parsed) {
+        return (typeof parsed === 'object' &&
+            parsed !== null &&
+            'requests' in parsed &&
+            Array.isArray(parsed.requests));
+    }
+    /**
+     * Execute a single RPC request
+     */
+    async executeRequest(request, connectionData) {
+        const startTime = Date.now();
+        const meta = { ...request.meta };
+        // Look up handler
+        let handler = this.methods.get(request.method);
+        // Check for wildcard handlers
+        if (!handler) {
+            const parts = request.method.split('.');
+            for (let i = parts.length - 1; i > 0; i--) {
+                const wildcardKey = parts.slice(0, i).join('.') + '.*';
+                handler = this.methods.get(wildcardKey);
+                if (handler)
+                    break;
+            }
+        }
+        if (!handler) {
+            return {
+                id: request.id,
+                error: { code: ErrorCodes.MethodNotFound, message: `Method not found: ${request.method}` },
+                meta: { ...meta, duration: Date.now() - startTime },
+            };
+        }
+        try {
+            // Execute handler
+            const result = await handler(request.params, this.buildContext(undefined, undefined, meta));
+            return {
+                id: request.id,
+                result,
+                meta: { ...meta, duration: Date.now() - startTime },
+            };
+        }
+        catch (error) {
+            // Handle RPC errors thrown by handler
+            if (typeof error === 'object' && error !== null && 'code' in error) {
+                const rpcError = error;
+                // Hide internal error details in production
+                if (this.env.NODE_ENV === 'production' && rpcError.code === ErrorCodes.InternalError) {
+                    return {
+                        id: request.id,
+                        error: { code: ErrorCodes.InternalError, message: 'Internal error' },
+                        meta: { ...meta, duration: Date.now() - startTime },
+                    };
+                }
+                return {
+                    id: request.id,
+                    error: {
+                        code: rpcError.code,
+                        message: rpcError.message || 'Error',
+                        data: rpcError.data,
+                    },
+                    meta: { ...meta, duration: Date.now() - startTime },
+                };
+            }
+            // Handle regular errors
+            const err = error;
+            // Hide internal error details in production
+            if (this.env.NODE_ENV === 'production') {
+                return {
+                    id: request.id,
+                    error: { code: ErrorCodes.InternalError, message: 'Internal error' },
+                    meta: { ...meta, duration: Date.now() - startTime },
+                };
+            }
+            return {
+                id: request.id,
+                error: {
+                    code: err.code || ErrorCodes.InternalError,
+                    message: err.message || 'Internal error',
+                    data: err.data,
+                },
+                meta: { ...meta, duration: Date.now() - startTime },
+            };
+        }
+    }
+    /**
+     * Set up idle timer for hibernation
+     */
+    setupIdleTimer(connectionId) {
+        if (!this.options.hibernation?.idleTimeout)
+            return;
+        const conn = this.connections.get(connectionId);
+        if (!conn)
+            return;
+        // Clear existing timer
+        if (conn.idleTimer) {
+            clearTimeout(conn.idleTimer);
+        }
+        conn.idleTimer = setTimeout(() => {
+            this.hibernateConnection(connectionId);
+        }, this.options.hibernation.idleTimeout);
+    }
+    /**
+     * Reset idle timer on activity
+     */
+    resetIdleTimer(connectionId) {
+        const conn = this.connections.get(connectionId);
+        if (!conn)
+            return;
+        conn.lastMessageAt = Date.now();
+        this.setupIdleTimer(connectionId);
+    }
+    /**
+     * Hibernate a connection
+     */
+    hibernateConnection(connectionId) {
+        const conn = this.connections.get(connectionId);
+        if (!conn || conn.status !== 'open')
+            return;
+        conn.status = 'hibernating';
+        conn.hibernatedAt = Date.now();
+        // Serialize attachment
+        try {
+            ;
+            conn.ws.serializeAttachment?.({
+                connectionId: conn.id,
+                subscriptions: conn.subscriptions,
+                data: conn.data,
+            });
+        }
+        catch {
+            // Ignore
+        }
+        // Set up max hibernation timer if configured
+        if (this.options.hibernation?.maxHibernationDuration) {
+            conn.hibernationTimer = setTimeout(() => {
+                conn.status = 'closed';
+                try {
+                    conn.ws.close(1000, 'Max hibernation duration exceeded');
+                }
+                catch {
+                    // Ignore
+                }
+            }, this.options.hibernation.maxHibernationDuration);
+        }
+    }
+    /**
+     * Check if client is rate limited
+     */
+    isRateLimited(clientId) {
+        if (!this.options.rateLimit)
+            return false;
+        const now = Date.now();
+        const state = this.rateLimitState.get(clientId);
+        if (!state || now - state.windowStart > this.options.rateLimit.windowMs) {
+            this.rateLimitState.set(clientId, { count: 1, windowStart: now });
+            return false;
+        }
+        state.count++;
+        return state.count > this.options.rateLimit.maxRequests;
+    }
+}
+// =============================================================================
+// Factory Functions
+// =============================================================================
+/**
+ * Create an RPC server with default configuration
+ *
+ * @param options - Server options (optional)
+ * @returns Configured RPC server
+ */
+export function createRPCServer(options) {
+    return new RPCServer(options);
+}
+/**
+ * Create method context from Durable Object state
+ *
+ * Utility for building context outside of server class.
+ *
+ * @param state - Durable Object state
+ * @param env - Environment bindings
+ * @param meta - Optional metadata
+ * @returns Method context
+ */
+export function createMethodContext(state, env, meta) {
+    return {
+        state,
+        env,
+        meta,
+    };
+}
+//# sourceMappingURL=server.js.map