@principal-ai/control-tower-core 0.1.0 → 0.1.2

package/dist/server/BaseServer.d.ts

@@ -0,0 +1,116 @@
+import type { Event, Room, RoomConfig, Lock } from '../types';
+import type { ITransportAdapter } from '../abstractions/TransportAdapter';
+import type { IAuthAdapter } from '../abstractions/AuthAdapter';
+import type { IStorageAdapter } from '../abstractions/StorageAdapter';
+import type { RoomManager } from '../abstractions/RoomManager';
+import type { LockManager } from '../abstractions/LockManager';
+import { TypedEventEmitter } from '../abstractions/EventEmitter';
+import type { Server as HttpServer } from 'http';
+import type { Server as HttpsServer } from 'https';
+import type { WebSocketServer } from 'ws';
+export interface ServerConfig {
+    transport: ITransportAdapter;
+    auth?: IAuthAdapter;
+    storage?: IStorageAdapter;
+    roomManager: RoomManager;
+    lockManager: LockManager;
+    defaultRoomConfig?: Partial<RoomConfig>;
+    httpServer?: HttpServer | HttpsServer;
+    webSocketPath?: string;
+    webSocketServer?: WebSocketServer;
+}
+export interface ConnectedClient {
+    id: string;
+    userId: string;
+    roomId: string | null;
+    authenticated: boolean;
+    connectedAt: number;
+}
+export interface ServerEvents {
+    started: {
+        port: number;
+    };
+    stopped: {};
+    client_connected: {
+        client: ConnectedClient;
+    };
+    client_disconnected: {
+        clientId: string;
+        reason: string;
+    };
+    client_authenticated: {
+        clientId: string;
+        userId: string;
+    };
+    room_created: {
+        room: Room;
+    };
+    room_deleted: {
+        roomId: string;
+    };
+    client_joined_room: {
+        clientId: string;
+        roomId: string;
+    };
+    client_left_room: {
+        clientId: string;
+        roomId: string;
+    };
+    event_broadcast: {
+        roomId: string;
+        event: Event;
+        fromClientId: string;
+    };
+    lock_acquired: {
+        lock: Lock;
+        clientId: string;
+    };
+    lock_released: {
+        lockId: string;
+        clientId: string;
+    };
+    error: {
+        error: Error;
+        context?: string;
+    };
+    [key: string]: unknown;
+}
+export declare class BaseServer extends TypedEventEmitter<ServerEvents> {
+    private transport;
+    private auth?;
+    private storage?;
+    private roomManager;
+    private lockManager;
+    private config;
+    private clients;
+    private clientMessageHandlers;
+    private running;
+    private initialized;
+    private mode;
+    constructor(config: ServerConfig);
+    start(port?: number): Promise<void>;
+    initialize(): Promise<void>;
+    stop(): Promise<void>;
+    private handleTransportMessage;
+    private handleTransportError;
+    private handleTransportClose;
+    private addClient;
+    private disconnectClient;
+    private createClientMessageHandler;
+    private handleAuthenticate;
+    private handleJoinRoom;
+    private handleLeaveRoom;
+    private handleBroadcastEvent;
+    private handleLockRequest;
+    private handleLockRelease;
+    private sendToClient;
+    private generateId;
+    createRoom(roomId: string, config: RoomConfig): Promise<Room>;
+    deleteRoom(roomId: string): Promise<void>;
+    getConnectedClients(): ConnectedClient[];
+    getClient(clientId: string): ConnectedClient | null;
+    isRunning(): boolean;
+    getMode(): 'standalone' | 'integration';
+    isInitialized(): boolean;
+}
+//# sourceMappingURL=BaseServer.d.ts.map

package/dist/server/BaseServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseServer.d.ts","sourceRoot":"","sources":["../../src/server/BaseServer.ts"],"names":[],"mappings":"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"}

package/dist/server/BaseServer.js

@@ -0,0 +1,422 @@
+import { TypedEventEmitter } from '../abstractions/EventEmitter';
+export class BaseServer extends TypedEventEmitter {
+    constructor(config) {
+        super();
+        this.clients = new Map();
+        this.clientMessageHandlers = new Map();
+        this.running = false;
+        this.initialized = false;
+        this.config = config;
+        this.transport = config.transport;
+        this.auth = config.auth;
+        this.storage = config.storage;
+        this.roomManager = config.roomManager;
+        this.lockManager = config.lockManager;
+        // Determine mode based on configuration
+        this.mode = (config.httpServer || config.webSocketServer) ? 'integration' : 'standalone';
+        // Set up transport event handlers
+        this.transport.onMessage(this.handleTransportMessage.bind(this));
+        this.transport.onError(this.handleTransportError.bind(this));
+        this.transport.onClose(this.handleTransportClose.bind(this));
+    }
+    // Server Lifecycle
+    async start(port) {
+        if (this.mode === 'integration') {
+            throw new Error('Cannot use start() in integration mode. Use initialize() instead.');
+        }
+        if (!port) {
+            throw new Error('Port is required for standalone mode');
+        }
+        if (this.running) {
+            throw new Error('Server is already running');
+        }
+        try {
+            await this.transport.connect(`ws://localhost:${port}`, { url: `ws://localhost:${port}` });
+            this.running = true;
+            this.initialized = true;
+            await this.emit('started', { port });
+        }
+        catch (error) {
+            await this.emit('error', { error: error, context: 'server_start' });
+            throw error;
+        }
+    }
+    async initialize() {
+        if (this.mode === 'standalone') {
+            throw new Error('Cannot use initialize() in standalone mode. Use start() instead.');
+        }
+        if (this.initialized) {
+            throw new Error('Server is already initialized');
+        }
+        try {
+            const transport = this.transport;
+            if (this.config.webSocketServer) {
+                // Attach to existing WebSocket server
+                if (typeof transport.attachToWebSocketServer === 'function') {
+                    await transport.attachToWebSocketServer(this.config.webSocketServer);
+                }
+                else {
+                    throw new Error('Transport adapter does not support attachToWebSocketServer');
+                }
+            }
+            else if (this.config.httpServer) {
+                // Attach to existing HTTP server
+                if (typeof transport.attach === 'function') {
+                    await transport.attach(this.config.httpServer, this.config.webSocketPath || '/ws');
+                }
+                else {
+                    throw new Error('Transport adapter does not support attach');
+                }
+            }
+            else {
+                throw new Error('Either httpServer or webSocketServer must be provided in integration mode');
+            }
+            this.running = true;
+            this.initialized = true;
+            await this.emit('started', { port: 0 }); // Port 0 indicates integration mode
+        }
+        catch (error) {
+            await this.emit('error', { error: error, context: 'server_initialize' });
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        // Disconnect all clients
+        for (const [clientId] of Array.from(this.clients)) {
+            await this.disconnectClient(clientId, 'Server shutting down');
+        }
+        try {
+            await this.transport.disconnect();
+        }
+        catch (error) {
+            await this.emit('error', { error: error, context: 'server_stop' });
+        }
+        this.clients.clear();
+        this.clientMessageHandlers.clear();
+        await this.emit('stopped', {});
+    }
+    // Client Management
+    async handleTransportMessage(message) {
+        // Transport messages contain clientId in the payload for routing
+        const payload = message.payload;
+        const { clientId, ...clientMessage } = payload;
+        const clientMsg = {
+            id: message.id,
+            type: message.type,
+            payload: clientMessage,
+            timestamp: message.timestamp
+        };
+        if (!clientId) {
+            await this.emit('error', {
+                error: new Error('Message missing clientId'),
+                context: 'transport_message'
+            });
+            return;
+        }
+        const handler = this.clientMessageHandlers.get(clientId);
+        if (handler) {
+            await handler(clientMsg);
+        }
+        else {
+            await this.emit('error', {
+                error: new Error(`No handler for client ${clientId}`),
+                context: 'transport_message'
+            });
+        }
+    }
+    async handleTransportError(error) {
+        await this.emit('error', { error, context: 'transport' });
+    }
+    async handleTransportClose(_code, _reason) {
+        // Transport close means server is shutting down
+        if (this.running) {
+            await this.stop();
+        }
+    }
+    async addClient(clientId) {
+        const client = {
+            id: clientId,
+            userId: '',
+            roomId: null,
+            authenticated: false,
+            connectedAt: Date.now()
+        };
+        this.clients.set(clientId, client);
+        // Set up message handler for this client
+        this.clientMessageHandlers.set(clientId, this.createClientMessageHandler(clientId));
+        await this.emit('client_connected', { client });
+    }
+    async disconnectClient(clientId, reason) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+            return;
+        }
+        // Leave room if in one
+        if (client.roomId) {
+            await this.roomManager.leaveRoom(client.roomId, client.userId);
+            await this.emit('client_left_room', { clientId, roomId: client.roomId });
+        }
+        // Release all locks held by this client
+        await this.lockManager.releaseUserLocks(client.userId);
+        // Clean up
+        this.clients.delete(clientId);
+        this.clientMessageHandlers.delete(clientId);
+        await this.emit('client_disconnected', { clientId, reason });
+    }
+    createClientMessageHandler(clientId) {
+        return async (message) => {
+            try {
+                const client = this.clients.get(clientId);
+                if (!client) {
+                    return;
+                }
+                switch (message.type) {
+                    case 'authenticate':
+                        await this.handleAuthenticate(clientId, message.payload);
+                        break;
+                    case 'join_room':
+                        await this.handleJoinRoom(clientId, message.payload);
+                        break;
+                    case 'leave_room':
+                        await this.handleLeaveRoom(clientId);
+                        break;
+                    case 'broadcast_event':
+                        await this.handleBroadcastEvent(clientId, message.payload);
+                        break;
+                    case 'request_lock':
+                        await this.handleLockRequest(clientId, message.payload);
+                        break;
+                    case 'release_lock':
+                        await this.handleLockRelease(clientId, message.payload);
+                        break;
+                    case 'ping':
+                        await this.sendToClient(clientId, { type: 'pong', timestamp: Date.now() });
+                        break;
+                    default:
+                        await this.sendToClient(clientId, {
+                            type: 'error',
+                            error: `Unknown message type: ${message.type}`
+                        });
+                }
+            }
+            catch (error) {
+                await this.sendToClient(clientId, {
+                    type: 'error',
+                    error: error.message
+                });
+                await this.emit('error', { error: error, context: `client_${clientId}` });
+            }
+        };
+    }
+    // Message Handlers
+    async handleAuthenticate(clientId, payload) {
+        if (!this.auth) {
+            await this.sendToClient(clientId, { type: 'auth_result', success: false, error: 'Authentication not configured' });
+            return;
+        }
+        try {
+            const tokenPayload = await this.auth.validateToken(payload.token);
+            const client = this.clients.get(clientId);
+            if (client) {
+                client.userId = tokenPayload.userId;
+                client.authenticated = true;
+                await this.emit('client_authenticated', { clientId, userId: tokenPayload.userId });
+            }
+            await this.sendToClient(clientId, { type: 'auth_result', success: true });
+        }
+        catch (error) {
+            await this.sendToClient(clientId, { type: 'auth_result', success: false, error: error.message });
+        }
+    }
+    async handleJoinRoom(clientId, payload) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+            return;
+        }
+        // Authenticate if token provided
+        if (payload.token && !client.authenticated) {
+            await this.handleAuthenticate(clientId, { token: payload.token });
+        }
+        if (!client.authenticated) {
+            await this.sendToClient(clientId, { type: 'error', error: 'Authentication required to join room' });
+            return;
+        }
+        try {
+            // Leave current room if any
+            if (client.roomId) {
+                await this.roomManager.leaveRoom(client.roomId, client.userId);
+                await this.emit('client_left_room', { clientId, roomId: client.roomId });
+            }
+            // Get or create room
+            let roomState = await this.roomManager.getRoomState(payload.roomId);
+            if (!roomState) {
+                const roomConfig = { ...this.config.defaultRoomConfig, id: payload.roomId };
+                const room = await this.roomManager.createRoom(payload.roomId, roomConfig);
+                roomState = await this.roomManager.getRoomState(payload.roomId);
+                await this.emit('room_created', { room });
+            }
+            if (!roomState) {
+                throw new Error('Failed to create or get room state');
+            }
+            // Join room
+            const user = {
+                id: client.userId,
+                username: client.userId, // TODO: Get from auth token
+                status: 'online',
+                joinedAt: Date.now(),
+                lastActivity: Date.now(),
+                permissions: roomState.room.permissions || ['read', 'write']
+            };
+            await this.roomManager.joinRoom(payload.roomId, user);
+            client.roomId = payload.roomId;
+            await this.emit('client_joined_room', { clientId, roomId: payload.roomId });
+            // Send room state to client
+            await this.sendToClient(clientId, {
+                type: 'room_joined',
+                roomId: payload.roomId,
+                state: roomState
+            });
+            // Send event history
+            const history = await this.roomManager.getEventHistory(payload.roomId, 50);
+            if (history.length > 0) {
+                await this.sendToClient(clientId, {
+                    type: 'event_history',
+                    events: history
+                });
+            }
+        }
+        catch (error) {
+            await this.sendToClient(clientId, { type: 'error', error: error.message });
+        }
+    }
+    async handleLeaveRoom(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client || !client.roomId) {
+            return;
+        }
+        const roomId = client.roomId;
+        await this.roomManager.leaveRoom(roomId, client.userId);
+        client.roomId = null;
+        await this.emit('client_left_room', { clientId, roomId });
+        await this.sendToClient(clientId, { type: 'room_left', roomId });
+    }
+    async handleBroadcastEvent(clientId, payload) {
+        const client = this.clients.get(clientId);
+        if (!client || client.roomId !== payload.roomId) {
+            await this.sendToClient(clientId, { type: 'error', error: 'Not in specified room' });
+            return;
+        }
+        // Add metadata to event
+        const enrichedEvent = {
+            ...payload.event,
+            metadata: {
+                ...payload.event.metadata,
+                userId: client.userId,
+                timestamp: Date.now(),
+                roomId: payload.roomId
+            }
+        };
+        // Add to history
+        await this.roomManager.addEventToHistory(payload.roomId, enrichedEvent);
+        // Broadcast to room
+        await this.roomManager.broadcastToRoom(payload.roomId, enrichedEvent, client.userId);
+        await this.emit('event_broadcast', {
+            roomId: payload.roomId,
+            event: enrichedEvent,
+            fromClientId: clientId
+        });
+    }
+    async handleLockRequest(clientId, payload) {
+        const client = this.clients.get(clientId);
+        if (!client || client.roomId !== payload.roomId) {
+            await this.sendToClient(clientId, { type: 'error', error: 'Not in specified room' });
+            return;
+        }
+        try {
+            const lock = await this.lockManager.acquireLock(client.userId, client.userId, payload.request);
+            await this.emit('lock_acquired', { lock, clientId });
+            await this.sendToClient(clientId, { type: 'lock_acquired', lock });
+            // Broadcast lock status to room
+            await this.roomManager.broadcastToRoom(payload.roomId, {
+                id: this.generateId(),
+                type: 'lock_status',
+                timestamp: Date.now(),
+                userId: client.userId,
+                roomId: payload.roomId,
+                data: { lock, action: 'acquired' },
+                metadata: { userId: client.userId, timestamp: Date.now(), roomId: payload.roomId }
+            });
+        }
+        catch (error) {
+            await this.sendToClient(clientId, { type: 'lock_denied', request: payload.request, reason: error.message });
+        }
+    }
+    async handleLockRelease(clientId, payload) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+            return;
+        }
+        try {
+            await this.lockManager.releaseLock(payload.lockId);
+            await this.emit('lock_released', { lockId: payload.lockId, clientId });
+            await this.sendToClient(clientId, { type: 'lock_released', lockId: payload.lockId });
+            // Broadcast lock status to room if client is in one
+            if (client.roomId) {
+                await this.roomManager.broadcastToRoom(client.roomId, {
+                    id: this.generateId(),
+                    type: 'lock_status',
+                    timestamp: Date.now(),
+                    userId: client.userId,
+                    roomId: client.roomId,
+                    data: { lockId: payload.lockId, action: 'released' },
+                    metadata: { userId: client.userId, timestamp: Date.now(), roomId: client.roomId }
+                });
+            }
+        }
+        catch (error) {
+            await this.sendToClient(clientId, { type: 'error', error: error.message });
+        }
+    }
+    // Utility Methods
+    async sendToClient(clientId, message) {
+        const transportMessage = {
+            id: this.generateId(),
+            type: 'server_message',
+            payload: { clientId, ...message },
+            timestamp: Date.now()
+        };
+        await this.transport.send(transportMessage);
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+    // Public API for external management
+    async createRoom(roomId, config) {
+        const room = await this.roomManager.createRoom(roomId, config);
+        await this.emit('room_created', { room });
+        return room;
+    }
+    async deleteRoom(roomId) {
+        await this.roomManager.deleteRoom(roomId);
+        await this.emit('room_deleted', { roomId });
+    }
+    getConnectedClients() {
+        return Array.from(this.clients.values());
+    }
+    getClient(clientId) {
+        return this.clients.get(clientId) || null;
+    }
+    isRunning() {
+        return this.running;
+    }
+    getMode() {
+        return this.mode;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}

package/dist/server/ServerBuilder.d.ts

@@ -0,0 +1,32 @@
+import type { ITransportAdapter } from '../abstractions/TransportAdapter';
+import type { IAuthAdapter } from '../abstractions/AuthAdapter';
+import type { IStorageAdapter } from '../abstractions/StorageAdapter';
+import type { RoomManager } from '../abstractions/RoomManager';
+import type { LockManager } from '../abstractions/LockManager';
+import type { RoomConfig } from '../types';
+import { BaseServer } from './BaseServer';
+import type { Server as HttpServer } from 'http';
+import type { Server as HttpsServer } from 'https';
+import type { WebSocketServer } from 'ws';
+export declare class ServerBuilder {
+    private transport?;
+    private auth?;
+    private storage?;
+    private roomManager?;
+    private lockManager?;
+    private defaultRoomConfig?;
+    private httpServer?;
+    private webSocketPath?;
+    private webSocketServer?;
+    withTransport(transport: ITransportAdapter): this;
+    withAuth(auth: IAuthAdapter): this;
+    withStorage(storage: IStorageAdapter): this;
+    withRoomManager(roomManager: RoomManager): this;
+    withLockManager(lockManager: LockManager): this;
+    withDefaultRoomConfig(config: Partial<RoomConfig>): this;
+    withHttpServer(server: HttpServer | HttpsServer): this;
+    withWebSocketPath(path: string): this;
+    withWebSocketServer(wss: WebSocketServer): this;
+    build(): BaseServer;
+}
+//# sourceMappingURL=ServerBuilder.d.ts.map

package/dist/server/ServerBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerBuilder.d.ts","sourceRoot":"","sources":["../../src/server/ServerBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAqB,MAAM,cAAc,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAC,CAAoB;IACtC,OAAO,CAAC,IAAI,CAAC,CAAe;IAC5B,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAChD,OAAO,CAAC,UAAU,CAAC,CAA2B;IAC9C,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,eAAe,CAAC,CAAkB;IAE1C,aAAa,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IAKjD,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAKlC,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAK3C,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAK/C,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAK/C,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI;IAKxD,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI;IAKtD,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKrC,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IAK/C,KAAK,IAAI,UAAU;CA+BpB"}

package/dist/server/ServerBuilder.js

@@ -0,0 +1,66 @@
+import { BaseServer } from './BaseServer';
+export class ServerBuilder {
+    withTransport(transport) {
+        this.transport = transport;
+        return this;
+    }
+    withAuth(auth) {
+        this.auth = auth;
+        return this;
+    }
+    withStorage(storage) {
+        this.storage = storage;
+        return this;
+    }
+    withRoomManager(roomManager) {
+        this.roomManager = roomManager;
+        return this;
+    }
+    withLockManager(lockManager) {
+        this.lockManager = lockManager;
+        return this;
+    }
+    withDefaultRoomConfig(config) {
+        this.defaultRoomConfig = config;
+        return this;
+    }
+    withHttpServer(server) {
+        this.httpServer = server;
+        return this;
+    }
+    withWebSocketPath(path) {
+        this.webSocketPath = path;
+        return this;
+    }
+    withWebSocketServer(wss) {
+        this.webSocketServer = wss;
+        return this;
+    }
+    build() {
+        if (!this.transport) {
+            throw new Error('Transport adapter is required');
+        }
+        if (!this.roomManager) {
+            throw new Error('Room manager is required');
+        }
+        if (!this.lockManager) {
+            throw new Error('Lock manager is required');
+        }
+        const config = {
+            transport: this.transport,
+            auth: this.auth,
+            storage: this.storage,
+            roomManager: this.roomManager,
+            lockManager: this.lockManager,
+            defaultRoomConfig: this.defaultRoomConfig || {
+                maxUsers: 50,
+                maxHistory: 100,
+                permissions: ['read', 'write']
+            },
+            httpServer: this.httpServer,
+            webSocketPath: this.webSocketPath,
+            webSocketServer: this.webSocketServer
+        };
+        return new BaseServer(config);
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export { BaseServer, type ServerConfig, type ServerEvents, type ConnectedClient } from './BaseServer';
+export { ServerBuilder } from './ServerBuilder';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACtG,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,3 @@
+// Server-side implementations
+export { BaseServer } from './BaseServer';
+export { ServerBuilder } from './ServerBuilder';