@owlmeans/socket 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,434 @@
+# @owlmeans/socket
+
+Common WebSocket communication library for OwlMeans applications. This package provides a unified abstraction for real-time communication across server, web, and mobile environments with support for RPC calls, event handling, authentication, and message queuing.
+
+## Overview
+
+The `@owlmeans/socket` package provides:
+
+- **Connection Abstraction**: Unified interface for WebSocket connections across platforms
+- **RPC Communication**: Remote procedure call support with timeout and error handling
+- **Event System**: Publish/subscribe event handling for real-time updates
+- **Authentication Integration**: Built-in authentication flow support
+- **Message Queuing**: Queue management for reliable message delivery
+- **Request/Response Pattern**: Structured request/response communication
+- **Error Handling**: Comprehensive error handling with resilient error types
+
+## Installation
+
+```bash
+npm install @owlmeans/socket
+```
+
+## Core Concepts
+
+### Connection Interface
+
+The `Connection` interface provides a unified API for WebSocket communication, supporting various message types and communication patterns.
+
+### Message Types
+
+Different message types enable various communication patterns:
+- **Call/Result**: RPC-style method calls with responses
+- **Request/Response**: Structured request/response patterns
+- **Event**: Publish/subscribe event notifications
+- **Auth**: Authentication-specific messages
+
+### Authentication Integration
+
+Built-in support for authentication flows with stage-based progression and secure communication.
+
+## API Reference
+
+### Types
+
+#### `Connection`
+Core connection interface for WebSocket communication.
+
+```typescript
+interface Connection {
+  stage: AuthenticationStage                    // Current authentication stage
+  notify: <T>(event: string, payload: T) => Promise<void>     // Send events
+  observe: <T>(event: string, handler: (event: EventMessage<T>) => Promise<void>) => () => void  // Listen to events
+  call: <R, T extends any[]>(method: string, ...payload: T) => Promise<R>  // RPC calls
+  perform: <R, T extends any[]>(method: string, handler: CallHendler<R, T>) => void  // Handle RPC calls
+  request: <T, R>(payload: T, observer?: (payload: R) => Promise<boolean>) => Promise<() => void>  // Send requests
+  reply: <T>(id: string, payload: T) => Promise<void>         // Reply to requests
+  auth: <T, R>(stage: AuthenticationStage, payload: T) => Promise<R>  // Authentication
+  close: () => Promise<void>                    // Close connection
+}
+```
+
+#### `Message<T>`
+Base message structure for all communication.
+
+```typescript
+interface Message<T> {
+  type: MessageType     // Message type identifier
+  id?: string          // Unique message ID
+  sender?: string      // Sender identifier
+  recipient?: string   // Recipient identifier
+  dt?: number         // Timestamp
+  payload: T          // Message payload
+}
+```
+
+#### `MessageType`
+Enumeration of supported message types.
+
+```typescript
+enum MessageType {
+  Call = 'call',          // RPC method calls
+  Result = 'result',      // RPC method results
+  Error = 'error',        // Error responses
+  Request = 'request',    // Request messages
+  Response = 'response',  // Response messages
+  Event = 'event',        // Event notifications
+  Message = 'message',    // General messages
+  Auth = 'auth',          // Authentication messages
+  System = 'system'       // System messages
+}
+```
+
+## Usage Examples
+
+### Basic Connection Usage
+
+```typescript
+import { Connection, MessageType } from '@owlmeans/socket'
+
+// Assuming connection is established
+const connection: Connection = await createConnection()
+
+// Send an event
+await connection.notify('user-online', { userId: '123', status: 'active' })
+
+// Listen for events
+const unsubscribe = connection.observe('chat-message', async (event) => {
+  console.log('New message:', event.payload)
+})
+
+// Make RPC call
+const result = await connection.call('getUserProfile', '123')
+console.log('User profile:', result)
+
+// Handle RPC calls
+connection.perform('echo', async (message: string) => {
+  return `Echo: ${message}`
+})
+```
+
+### Event System
+
+```typescript
+// Publisher
+await connection.notify('order-status-changed', {
+  orderId: 'order-123',
+  status: 'shipped',
+  timestamp: Date.now()
+})
+
+// Subscriber
+const unsubscribe = connection.observe('order-status-changed', async (event) => {
+  const { orderId, status } = event.payload
+  console.log(`Order ${orderId} is now ${status}`)
+  
+  // Update UI or trigger other actions
+  await updateOrderDisplay(orderId, status)
+})
+
+// Cleanup
+unsubscribe()
+```
+
+### RPC Communication
+
+```typescript
+// Client-side: Make calls
+try {
+  const users = await connection.call('getUsers', { page: 1, limit: 10 })
+  const user = await connection.call('getUserById', '123')
+  const updated = await connection.call('updateUser', '123', { name: 'John Doe' })
+} catch (error) {
+  console.error('RPC call failed:', error)
+}
+
+// Server-side: Handle calls
+connection.perform('getUsers', async (options: { page: number, limit: number }) => {
+  const users = await userService.list(options)
+  return users
+})
+
+connection.perform('getUserById', async (id: string) => {
+  const user = await userService.get(id)
+  if (!user) {
+    throw new Error('User not found')
+  }
+  return user
+})
+
+connection.perform('updateUser', async (id: string, data: Partial<User>) => {
+  return await userService.update(id, data)
+})
+```
+
+### Request/Response Pattern
+
+```typescript
+// Send request and handle responses
+const unsubscribe = await connection.request(
+  { action: 'stream-data', filters: { category: 'important' } },
+  async (response) => {
+    console.log('Received chunk:', response)
+    // Return true to continue receiving, false to stop
+    return response.hasMore
+  }
+)
+
+// Handle incoming requests
+const unsubscribeHandler = connection.acknowledge(async (id: string, payload: any) => {
+  const { action, filters } = payload
+  
+  if (action === 'stream-data') {
+    // Process request and send responses
+    const chunks = await getDataChunks(filters)
+    
+    for (const chunk of chunks) {
+      await connection.reply(id, {
+        data: chunk,
+        hasMore: chunk.index < chunks.length - 1
+      })
+    }
+    
+    return true // Request handled
+  }
+  
+  return false // Request not handled
+})
+```
+
+### Authentication Flow
+
+```typescript
+// Authenticate connection
+try {
+  // Start authentication
+  let stage = AuthenticationStage.Init
+  let result = await connection.auth(stage, { clientId: 'my-app' })
+  
+  // Continue authentication based on challenge
+  if (result.challenge) {
+    stage = AuthenticationStage.Authenticate
+    result = await connection.auth(stage, {
+      response: await generateAuthResponse(result.challenge)
+    })
+  }
+  
+  console.log('Authentication successful:', result)
+} catch (error) {
+  console.error('Authentication failed:', error)
+}
+
+// Check authentication status
+if (connection.stage === AuthenticationStage.Authenticated) {
+  // Perform authenticated operations
+  await connection.call('getProtectedData')
+}
+```
+
+### Message Queuing
+
+```typescript
+// Enqueue messages for delivery
+await connection.enqueue({ 
+  type: 'user-notification',
+  userId: '123',
+  message: 'Welcome!'
+})
+
+await connection.enqueue({
+  type: 'system-alert',
+  level: 'warning',
+  text: 'Maintenance scheduled'
+}, 'maintenance-alert-1')
+
+// Check queue status
+const queueSize = connection.enqueued()
+console.log(`${queueSize} messages queued`)
+
+// Consume queued messages
+const consumed = connection.consume()
+if (consumed) {
+  const [payload, id, remaining] = consumed
+  console.log('Consumed message:', payload, 'ID:', id, 'Remaining:', remaining)
+}
+
+// Consume with filter
+const alertsOnly = connection.consume((payload: any) => payload.type === 'system-alert')
+```
+
+### Connection Lifecycle
+
+```typescript
+// Listen to connection events
+const unsubscribeListener = connection.listen(async (message) => {
+  console.log('Connection message:', message)
+  
+  // Handle connection-level events
+  if (typeof message === 'string') {
+    console.log('Raw message:', message)
+  } else {
+    switch (message.type) {
+      case MessageType.System:
+        console.log('System message:', message.payload)
+        break
+      case MessageType.Error:
+        console.error('Connection error:', message.payload)
+        break
+    }
+  }
+})
+
+// Handle connection cleanup
+const handleConnectionClose = async () => {
+  // Unsubscribe from events
+  unsubscribeListener()
+  
+  // Clean up resources
+  await connection.close()
+}
+
+// Handle process termination
+process.on('SIGTERM', handleConnectionClose)
+process.on('SIGINT', handleConnectionClose)
+```
+
+### Error Handling
+
+```typescript
+import { SocketError } from '@owlmeans/socket'
+
+try {
+  await connection.call('riskyOperation', data)
+} catch (error) {
+  if (error instanceof SocketError) {
+    console.error('Socket error:', error.message)
+    
+    // Handle specific socket errors
+    switch (error.code) {
+      case 'TIMEOUT':
+        console.log('Call timed out')
+        break
+      case 'CONNECTION_LOST':
+        console.log('Connection lost, attempting reconnect...')
+        await reconnectSocket()
+        break
+      case 'AUTH_FAILED':
+        console.log('Authentication failed')
+        await reauthenticate()
+        break
+    }
+  }
+}
+```
+
+## Advanced Features
+
+### Custom Message Preparation
+
+```typescript
+// Implement custom message preparation
+const customConnection: Connection = {
+  ...baseConnection,
+  
+  prepare: <T>(message: Message<T>, isRequest?: boolean) => {
+    // Add custom headers or encryption
+    return {
+      ...message,
+      sender: 'my-service',
+      dt: Date.now(),
+      // Add custom processing
+    }
+  }
+}
+```
+
+### Timeout Configuration
+
+```typescript
+// Set default timeout
+connection.defaultCallTimeout = 30000 // 30 seconds
+
+// Use custom timeout for specific calls
+try {
+  const result = await connection.call('longRunningOperation', data)
+} catch (error) {
+  if (error.message.includes('timeout')) {
+    console.log('Operation timed out')
+  }
+}
+```
+
+### Connection Multiplexing
+
+```typescript
+// Handle multiple concurrent operations
+const operations = [
+  connection.call('operation1', data1),
+  connection.call('operation2', data2),
+  connection.call('operation3', data3)
+]
+
+const results = await Promise.allSettled(operations)
+results.forEach((result, index) => {
+  if (result.status === 'fulfilled') {
+    console.log(`Operation ${index + 1} succeeded:`, result.value)
+  } else {
+    console.error(`Operation ${index + 1} failed:`, result.reason)
+  }
+})
+```
+
+## Integration with OwlMeans Ecosystem
+
+The `@owlmeans/socket` package integrates with:
+
+- **@owlmeans/auth**: Authentication stages and flows
+- **@owlmeans/error**: Resilient error handling
+- **@owlmeans/client-socket**: Client-side WebSocket implementation
+- **@owlmeans/server-socket**: Server-side WebSocket implementation
+- **@owlmeans/context**: Service registration and lifecycle management
+
+## Constants
+
+```typescript
+const CALL_TIMEOUT = 60000  // Default RPC call timeout (60 seconds)
+```
+
+## Best Practices
+
+### Connection Management
+- Always handle connection lifecycle events
+- Implement proper reconnection logic
+- Clean up event listeners on disconnect
+- Use appropriate timeouts for different operations
+
+### Error Handling
+- Implement comprehensive error handling for all communication patterns
+- Use appropriate retry strategies for failed operations
+- Log connection events for debugging
+- Handle authentication failures gracefully
+
+### Performance
+- Use appropriate message batching for high-frequency events
+- Implement efficient event filtering
+- Consider message compression for large payloads
+- Monitor connection performance and adjust timeouts
+
+### Security
+- Always authenticate connections before sensitive operations
+- Validate all incoming messages and payloads
+- Use secure WebSocket connections (WSS) in production
+- Implement proper authorization checks for RPC methods
+
+Fixes #32.

package/build/consts.d.ts

@@ -0,0 +1,13 @@
+export declare enum MessageType {
+    Call = "call",
+    Result = "result",
+    Error = "error",
+    Request = "request",
+    Response = "response",
+    Event = "event",
+    Message = "message",
+    Auth = "auth",
+    System = "system"
+}
+export declare const CALL_TIMEOUT = 60000;
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,WAAW;IACrB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,YAAY,QAAQ,CAAA"}

package/build/consts.js

@@ -0,0 +1,14 @@
+export var MessageType;
+(function (MessageType) {
+    MessageType["Call"] = "call";
+    MessageType["Result"] = "result";
+    MessageType["Error"] = "error";
+    MessageType["Request"] = "request";
+    MessageType["Response"] = "response";
+    MessageType["Event"] = "event";
+    MessageType["Message"] = "message";
+    MessageType["Auth"] = "auth";
+    MessageType["System"] = "system";
+})(MessageType || (MessageType = {}));
+export const CALL_TIMEOUT = 60000;
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,WAUX;AAVD,WAAY,WAAW;IACrB,4BAAa,CAAA;IACb,gCAAiB,CAAA;IACjB,8BAAe,CAAA;IACf,kCAAmB,CAAA;IACnB,oCAAqB,CAAA;IACrB,8BAAe,CAAA;IACf,kCAAmB,CAAA;IACnB,4BAAa,CAAA;IACb,gCAAiB,CAAA;AACnB,CAAC,EAVW,WAAW,KAAX,WAAW,QAUtB;AAED,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,CAAA"}

package/build/errors.d.ts

@@ -0,0 +1,34 @@
+import { ResilientError } from '@owlmeans/error';
+export declare class SocketError extends ResilientError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketInitializationError extends SocketError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketConnectionError extends SocketError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketUnauthorized extends SocketConnectionError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketUnsupported extends SocketConnectionError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketTimeout extends SocketError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketMessageError extends SocketError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class SocketMessageMalformed extends SocketMessageError {
+    static typeName: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,qBAAa,WAAY,SAAQ,cAAc;IAC7C,OAAuB,QAAQ,EAAE,MAAM,CAAgB;gBAE3C,OAAO,GAAE,MAAgB;CAGtC;AAED,qBAAa,yBAA0B,SAAQ,WAAW;IACxD,OAAuB,QAAQ,EAAE,MAAM,CAA0C;gBAErE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,OAAuB,QAAQ,EAAE,MAAM,CAAsC;gBAEjE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,kBAAmB,SAAQ,qBAAqB;IAC3D,OAAuB,QAAQ,EAAE,MAAM,CAAkD;gBAE7E,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,iBAAkB,SAAQ,qBAAqB;IAC1D,OAAuB,QAAQ,EAAE,MAAM,CAAiD;gBAE5E,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,aAAc,SAAQ,WAAW;IAC5C,OAAuB,QAAQ,EAAE,MAAM,CAAmC;gBAE9D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,OAAuB,QAAQ,EAAE,MAAM,CAAmC;gBAE9D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,OAAuB,QAAQ,EAAE,MAAM,CAA4C;gBAEvE,OAAO,GAAE,MAAgB;CAItC"}

package/build/errors.js

@@ -0,0 +1,65 @@
+import { ResilientError } from '@owlmeans/error';
+export class SocketError extends ResilientError {
+    static typeName = 'SocketError';
+    constructor(message = 'error') {
+        super(SocketError.typeName, `socket:${message}`);
+    }
+}
+export class SocketInitializationError extends SocketError {
+    static typeName = `${SocketError.typeName}Initialization`;
+    constructor(message = 'error') {
+        super(`initialization:${message}`);
+        this.type = SocketInitializationError.typeName;
+    }
+}
+export class SocketConnectionError extends SocketError {
+    static typeName = `${SocketError.typeName}Connection`;
+    constructor(message = 'error') {
+        super(`connection:${message}`);
+        this.type = SocketConnectionError.typeName;
+    }
+}
+export class SocketUnauthorized extends SocketConnectionError {
+    static typeName = `${SocketConnectionError.typeName}Unauthorized`;
+    constructor(message = 'error') {
+        super(`unauthorized:${message}`);
+        this.type = SocketUnauthorized.typeName;
+    }
+}
+export class SocketUnsupported extends SocketConnectionError {
+    static typeName = `${SocketConnectionError.typeName}Unsupported`;
+    constructor(message = 'error') {
+        super(`unsupported:${message}`);
+        this.type = SocketUnsupported.typeName;
+    }
+}
+export class SocketTimeout extends SocketError {
+    static typeName = `${SocketError.typeName}Timeout`;
+    constructor(message = 'error') {
+        super(`timeout:${message}`);
+        this.type = SocketTimeout.typeName;
+    }
+}
+export class SocketMessageError extends SocketError {
+    static typeName = `${SocketError.typeName}Message`;
+    constructor(message = 'error') {
+        super(`message:${message}`);
+        this.type = SocketMessageError.typeName;
+    }
+}
+export class SocketMessageMalformed extends SocketMessageError {
+    static typeName = `${SocketMessageError.typeName}Malformed`;
+    constructor(message = 'error') {
+        super(`malformed:${message}`);
+        this.type = SocketMessageMalformed.typeName;
+    }
+}
+ResilientError.registerErrorClass(SocketError);
+ResilientError.registerErrorClass(SocketInitializationError);
+ResilientError.registerErrorClass(SocketConnectionError);
+ResilientError.registerErrorClass(SocketUnauthorized);
+ResilientError.registerErrorClass(SocketUnsupported);
+ResilientError.registerErrorClass(SocketTimeout);
+ResilientError.registerErrorClass(SocketMessageError);
+ResilientError.registerErrorClass(SocketMessageMalformed);
+//# sourceMappingURL=errors.js.map

package/build/errors.js.map

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

package/build/helper.d.ts

@@ -0,0 +1,6 @@
+import type { CallMessage, EventMessage, Message, AuthMessage } from './types.js';
+export declare const isMessage: <P, T extends Message<P>>(msg: string | T, nonSystem?: boolean) => msg is T;
+export declare const isEventMessage: <P>(msg: string | Message<P>, system?: boolean) => msg is EventMessage<P>;
+export declare const isCallMessage: <P extends any[]>(msg: string | Message<unknown>) => msg is CallMessage<P>;
+export declare const isAuthMessage: <P>(msg: string | Message<P>) => msg is AuthMessage<P>;
+//# sourceMappingURL=helper.d.ts.map

package/build/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAEjF,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,OAAO,MAAM,GAAG,CAAC,cAAc,OAAO,KAAG,GAAG,IAAI,CAEhB,CAAA;AAEjF,eAAO,MAAM,cAAc,GAAI,CAAC,OAAO,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,WAAW,OAAO,KAAG,GAAG,IAAI,YAAY,CAAC,CAAC,CAEzB,CAAA;AAE3E,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,GAAG,EAAE,OAAO,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,KAAG,GAAG,IAAI,WAAW,CAAC,CAAC,CACnD,CAAA;AAEjD,eAAO,MAAM,aAAa,GAAI,CAAC,OAAO,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,KAAG,GAAG,IAAI,WAAW,CAAC,CAAC,CAC/B,CAAA"}

package/build/helper.js

@@ -0,0 +1,26 @@
+import { MessageType } from './consts.js';
+export const isMessage = (msg, nonSystem) => typeof msg === 'object' && 'type' in msg && 'payload' in msg
+    && (nonSystem === undefined || nonSystem === (msg.type !== MessageType.System));
+export const isEventMessage = (msg, system) => isMessage(msg) && [MessageType.Event, MessageType.System].includes(msg.type)
+    && (system === undefined || system === (msg.type === MessageType.System));
+export const isCallMessage = (msg) => isMessage(msg) && msg.type === MessageType.Call;
+export const isAuthMessage = (msg) => isMessage(msg) && msg.type === MessageType.Auth;
+// export const prepareLongCalls = (connection: Connection, longTimeout = CALL_TIMEOUT * 10) => {
+//   const _connection = connection as WithLongCalls
+//   if (_connection[long_calls] == null) {
+//     const prepare = connection.prepare
+//     connection.prepare = (message, isRequest) => {
+//       if (!isRequest && isCallMessage(message)) {
+//         message.timeout = longTimeout
+//       }
+//       return prepare?.(message, isRequest) ?? message
+//     }
+//     _connection[long_calls] = true
+//   }
+//   return connection
+// }
+// const long_calls = Symbol('__prepare_with_long_calls')
+// interface WithLongCalls extends Connection {
+//   [long_calls]: boolean
+// }
+//# sourceMappingURL=helper.js.map

package/build/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGzC,MAAM,CAAC,MAAM,SAAS,GAAG,CAA0B,GAAe,EAAE,SAAmB,EAAY,EAAE,CACnG,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG;OACzD,CAAC,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAA;AAEjF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAI,GAAwB,EAAE,MAAgB,EAA0B,EAAE,CACtG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;OACzE,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,MAAM,CAAC,CAAC,CAAA;AAE3E,MAAM,CAAC,MAAM,aAAa,GAAG,CAAkB,GAA8B,EAAyB,EAAE,CACtG,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,CAAA;AAEjD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAI,GAAwB,EAAyB,EAAE,CAClF,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,CAAA;AAGjD,iGAAiG;AACjG,oDAAoD;AACpD,2CAA2C;AAC3C,yCAAyC;AACzC,qDAAqD;AACrD,oDAAoD;AACpD,wCAAwC;AACxC,UAAU;AAEV,wDAAwD;AACxD,QAAQ;AACR,qCAAqC;AACrC,MAAM;AAEN,sBAAsB;AACtB,IAAI;AAEJ,yDAAyD;AACzD,+CAA+C;AAC/C,0BAA0B;AAC1B,IAAI"}

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export type * from './types.js';
+export * from './consts.js';
+export * from './model.js';
+export * from './errors.js';
+export * from './helper.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -0,0 +1,5 @@
+export * from './consts.js';
+export * from './model.js';
+export * from './errors.js';
+export * from './helper.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/build/model.d.ts

@@ -0,0 +1,3 @@
+import type { Connection } from './types.js';
+export declare const createBasicConnection: () => Connection;
+//# sourceMappingURL=model.d.ts.map

package/build/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAC2C,UAAU,EAEhE,MAAM,YAAY,CAAA;AAInB,eAAO,MAAM,qBAAqB,QAAO,UA+VxC,CAAA"}