@hla4ts/transport 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hla4ts/transport",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "HLA 4 Federate Protocol transport layer with TLS and message framing",
   "type": "module",
   "main": "src/index.ts",
@@ -22,7 +22,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@hla4ts/proto": "^0.1.0"
+    "@hla4ts/proto": "^0.1.1"
   },
   "devDependencies": {
     "typescript": "^5.3.3"

package/src/constants.ts

@@ -1,57 +1,57 @@
-/**
- * Federate Protocol Constants
- */
-
-/** Current Federate Protocol version */
-export const FEDERATE_PROTOCOL_VERSION = 1;
-
-/** Default ports for different transport protocols */
-export const Ports = {
-  /** Plain TCP (unencrypted) */
-  TCP: 15164,
-  /** TLS over TCP (encrypted) */
-  TLS: 15165,
-  /** WebSocket (unencrypted) */
-  WS: 80,
-  /** WebSocket Secure (encrypted) */
-  WSS: 443,
-} as const;
-
-/** Transport protocol names */
-export const Protocol = {
-  TCP: "tcp",
-  TLS: "tls",
-  WS: "websocket",
-  WSS: "websocketsecure",
-} as const;
-
-export type ProtocolType = (typeof Protocol)[keyof typeof Protocol];
-
-/** New session status reason codes */
-export const NewSessionStatus = {
-  /** Session created successfully */
-  SUCCESS: 0,
-  /** Server doesn't support the requested protocol version */
-  UNSUPPORTED_PROTOCOL_VERSION: 1,
-  /** Server is out of resources */
-  OUT_OF_RESOURCES: 2,
-  /** Bad message received */
-  BAD_MESSAGE: 3,
-  /** Other unspecified error */
-  OTHER_ERROR: 99,
-} as const;
-
-export type NewSessionStatusCode =
-  (typeof NewSessionStatus)[keyof typeof NewSessionStatus];
-
-/** Resume status reason codes */
-export const ResumeStatus = {
-  /** Resume successful */
-  SUCCESS: 0,
-  /** Session not found (expired or invalid) */
-  SESSION_NOT_FOUND: 1,
-  /** Resume not allowed in current state */
-  NOT_ALLOWED: 2,
-} as const;
-
-export type ResumeStatusCode = (typeof ResumeStatus)[keyof typeof ResumeStatus];
+/**
+ * Federate Protocol Constants
+ */
+
+/** Current Federate Protocol version */
+export const FEDERATE_PROTOCOL_VERSION = 1;
+
+/** Default ports for different transport protocols */
+export const Ports = {
+  /** Plain TCP (unencrypted) */
+  TCP: 15164,
+  /** TLS over TCP (encrypted) */
+  TLS: 15165,
+  /** WebSocket (unencrypted) */
+  WS: 80,
+  /** WebSocket Secure (encrypted) */
+  WSS: 443,
+} as const;
+
+/** Transport protocol names */
+export const Protocol = {
+  TCP: "tcp",
+  TLS: "tls",
+  WS: "websocket",
+  WSS: "websocketsecure",
+} as const;
+
+export type ProtocolType = (typeof Protocol)[keyof typeof Protocol];
+
+/** New session status reason codes */
+export const NewSessionStatus = {
+  /** Session created successfully */
+  SUCCESS: 0,
+  /** Server doesn't support the requested protocol version */
+  UNSUPPORTED_PROTOCOL_VERSION: 1,
+  /** Server is out of resources */
+  OUT_OF_RESOURCES: 2,
+  /** Bad message received */
+  BAD_MESSAGE: 3,
+  /** Other unspecified error */
+  OTHER_ERROR: 99,
+} as const;
+
+export type NewSessionStatusCode =
+  (typeof NewSessionStatus)[keyof typeof NewSessionStatus];
+
+/** Resume status reason codes */
+export const ResumeStatus = {
+  /** Resume successful */
+  SUCCESS: 0,
+  /** Session not found (expired or invalid) */
+  SESSION_NOT_FOUND: 1,
+  /** Resume not allowed in current state */
+  NOT_ALLOWED: 2,
+} as const;
+
+export type ResumeStatusCode = (typeof ResumeStatus)[keyof typeof ResumeStatus];

package/src/frame-decoder.ts

@@ -1,136 +1,136 @@
-/**
- * Frame Decoder
- *
- * Handles accumulating partial data from the network and extracting
- * complete framed messages. This is necessary because TCP is a stream
- * protocol and messages may arrive in fragments or multiple messages
- * may arrive in a single chunk.
- */
-
-import {
-  HEADER_SIZE,
-  decodeHeader,
-  type MessageHeader,
-} from "./message-header.ts";
-import type { ReceivedMessage } from "./transport.ts";
-
-/** Maximum allowed message size (16 MB) - protection against malformed packets */
-const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
-
-/**
- * Frame decoder for length-prefixed messages
- *
- * Usage:
- * ```ts
- * const decoder = new FrameDecoder();
- * decoder.onMessage = (msg) => console.log('Got message:', msg);
- *
- * // Feed data as it arrives from the socket
- * socket.on('data', (chunk) => decoder.push(chunk));
- * ```
- */
-export class FrameDecoder {
-  private buffer: Uint8Array = new Uint8Array(0);
-  private pendingHeader: MessageHeader | null = null;
-
-  /** Callback for complete messages */
-  public onMessage: ((message: ReceivedMessage) => void) | null = null;
-
-  /** Callback for decode errors */
-  public onError: ((error: Error) => void) | null = null;
-
-  /**
-   * Push incoming data into the decoder
-   * @param chunk Data received from the network
-   */
-  push(chunk: Uint8Array): void {
-    // Append chunk to buffer
-    this.buffer = this.concat(this.buffer, chunk);
-
-    // Process as many complete messages as possible
-    this.processBuffer();
-  }
-
-  /**
-   * Reset the decoder state (e.g., after a connection reset)
-   */
-  reset(): void {
-    this.buffer = new Uint8Array(0);
-    this.pendingHeader = null;
-  }
-
-  /**
-   * Get the number of bytes currently buffered
-   */
-  get bufferedBytes(): number {
-    return this.buffer.length;
-  }
-
-  private processBuffer(): void {
-    while (true) {
-      // If we don't have a header yet, try to read one
-      if (this.pendingHeader === null) {
-        if (this.buffer.length < HEADER_SIZE) {
-          // Not enough data for header yet
-          return;
-        }
-
-        try {
-          this.pendingHeader = decodeHeader(this.buffer.subarray(0, HEADER_SIZE));
-        } catch (error) {
-          this.onError?.(error as Error);
-          // Skip one byte and try again (attempt to resync)
-          this.buffer = this.buffer.subarray(1);
-          continue;
-        }
-
-        // Validate packet size
-        if (this.pendingHeader.packetSize > MAX_MESSAGE_SIZE) {
-          this.onError?.(
-            new Error(
-              `Message too large: ${this.pendingHeader.packetSize} bytes (max: ${MAX_MESSAGE_SIZE})`
-            )
-          );
-          // Reset and skip this header
-          this.pendingHeader = null;
-          this.buffer = this.buffer.subarray(HEADER_SIZE);
-          continue;
-        }
-      }
-
-      // We have a header, check if we have the complete message
-      const totalSize = this.pendingHeader.packetSize;
-      if (this.buffer.length < totalSize) {
-        // Not enough data for complete message yet
-        return;
-      }
-
-      // Extract the complete message
-      const messageData = this.buffer.subarray(0, totalSize);
-      const payload = messageData.subarray(HEADER_SIZE);
-
-      // Create the received message
-      const message: ReceivedMessage = {
-        header: this.pendingHeader,
-        payload: new Uint8Array(payload), // Copy to avoid issues with buffer reuse
-      };
-
-      // Remove this message from buffer
-      this.buffer = this.buffer.subarray(totalSize);
-      this.pendingHeader = null;
-
-      // Emit the message
-      this.onMessage?.(message);
-    }
-  }
-
-  private concat(a: Uint8Array, b: Uint8Array): Uint8Array {
-    if (a.length === 0) return b;
-    if (b.length === 0) return a;
-
-    const result = new Uint8Array(a.length + b.length);
-    result.set(a, 0);
-    result.set(b, a.length);
-    return result;
-  }
-}
+/**
+ * Frame Decoder
+ *
+ * Handles accumulating partial data from the network and extracting
+ * complete framed messages. This is necessary because TCP is a stream
+ * protocol and messages may arrive in fragments or multiple messages
+ * may arrive in a single chunk.
+ */
+
+import {
+  HEADER_SIZE,
+  decodeHeader,
+  type MessageHeader,
+} from "./message-header.ts";
+import type { ReceivedMessage } from "./transport.ts";
+
+/** Maximum allowed message size (16 MB) - protection against malformed packets */
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+
+/**
+ * Frame decoder for length-prefixed messages
+ *
+ * Usage:
+ * ```ts
+ * const decoder = new FrameDecoder();
+ * decoder.onMessage = (msg) => console.log('Got message:', msg);
+ *
+ * // Feed data as it arrives from the socket
+ * socket.on('data', (chunk) => decoder.push(chunk));
+ * ```
+ */
+export class FrameDecoder {
+  private buffer: Uint8Array = new Uint8Array(0);
+  private pendingHeader: MessageHeader | null = null;
+
+  /** Callback for complete messages */
+  public onMessage: ((message: ReceivedMessage) => void) | null = null;
+
+  /** Callback for decode errors */
+  public onError: ((error: Error) => void) | null = null;
+
+  /**
+   * Push incoming data into the decoder
+   * @param chunk Data received from the network
+   */
+  push(chunk: Uint8Array): void {
+    // Append chunk to buffer
+    this.buffer = this.concat(this.buffer, chunk);
+
+    // Process as many complete messages as possible
+    this.processBuffer();
+  }
+
+  /**
+   * Reset the decoder state (e.g., after a connection reset)
+   */
+  reset(): void {
+    this.buffer = new Uint8Array(0);
+    this.pendingHeader = null;
+  }
+
+  /**
+   * Get the number of bytes currently buffered
+   */
+  get bufferedBytes(): number {
+    return this.buffer.length;
+  }
+
+  private processBuffer(): void {
+    while (true) {
+      // If we don't have a header yet, try to read one
+      if (this.pendingHeader === null) {
+        if (this.buffer.length < HEADER_SIZE) {
+          // Not enough data for header yet
+          return;
+        }
+
+        try {
+          this.pendingHeader = decodeHeader(this.buffer.subarray(0, HEADER_SIZE));
+        } catch (error) {
+          this.onError?.(error as Error);
+          // Skip one byte and try again (attempt to resync)
+          this.buffer = this.buffer.subarray(1);
+          continue;
+        }
+
+        // Validate packet size
+        if (this.pendingHeader.packetSize > MAX_MESSAGE_SIZE) {
+          this.onError?.(
+            new Error(
+              `Message too large: ${this.pendingHeader.packetSize} bytes (max: ${MAX_MESSAGE_SIZE})`
+            )
+          );
+          // Reset and skip this header
+          this.pendingHeader = null;
+          this.buffer = this.buffer.subarray(HEADER_SIZE);
+          continue;
+        }
+      }
+
+      // We have a header, check if we have the complete message
+      const totalSize = this.pendingHeader.packetSize;
+      if (this.buffer.length < totalSize) {
+        // Not enough data for complete message yet
+        return;
+      }
+
+      // Extract the complete message
+      const messageData = this.buffer.subarray(0, totalSize);
+      const payload = messageData.subarray(HEADER_SIZE);
+
+      // Create the received message
+      const message: ReceivedMessage = {
+        header: this.pendingHeader,
+        payload: new Uint8Array(payload), // Copy to avoid issues with buffer reuse
+      };
+
+      // Remove this message from buffer
+      this.buffer = this.buffer.subarray(totalSize);
+      this.pendingHeader = null;
+
+      // Emit the message
+      this.onMessage?.(message);
+    }
+  }
+
+  private concat(a: Uint8Array, b: Uint8Array): Uint8Array {
+    if (a.length === 0) return b;
+    if (b.length === 0) return a;
+
+    const result = new Uint8Array(a.length + b.length);
+    result.set(a, 0);
+    result.set(b, a.length);
+    return result;
+  }
+}

package/src/index.ts

@@ -1,82 +1,82 @@
-/**
- * @hla4ts/transport - HLA 4 Federate Protocol Transport Layer
- *
- * This package provides transport implementations for the HLA 4 Federate Protocol,
- * including message framing, TLS support, and connection management.
- *
- * @example
- * ```ts
- * import { TlsTransport, MessageType, encodeMessage } from '@hla4ts/transport';
- *
- * // Create a TLS transport
- * const transport = new TlsTransport({
- *   host: 'rti.example.com',
- *   port: 15165,
- * });
- *
- * // Set up event handlers
- * transport.setEventHandlers({
- *   onMessage: (msg) => {
- *     console.log('Received:', MessageType[msg.header.messageType]);
- *   },
- *   onClose: () => console.log('Connection closed'),
- *   onError: (err) => console.error('Error:', err),
- * });
- *
- * // Connect and send a message
- * await transport.connect();
- * const message = encodeMessage(
- *   1,                              // sequence number
- *   0n,                             // session ID (0 for new session)
- *   0,                              // last received seq num
- *   MessageType.CTRL_NEW_SESSION,   // message type
- *   payload                         // optional payload
- * );
- * await transport.send(message);
- * ```
- *
- * @packageDocumentation
- */
-
-// Message types
-export { MessageType, isControlMessage, isHlaResponse, messageTypeName } from "./message-type.ts";
-
-// Message header encoding/decoding
-export {
-  HEADER_SIZE,
-  NO_SESSION_ID,
-  NO_SEQUENCE_NUMBER,
-  encodeHeader,
-  decodeHeader,
-  encodeMessage,
-  getPayloadSize,
-  type MessageHeader,
-} from "./message-header.ts";
-
-// Constants
-export {
-  FEDERATE_PROTOCOL_VERSION,
-  Ports,
-  Protocol,
-  NewSessionStatus,
-  ResumeStatus,
-  type ProtocolType,
-  type NewSessionStatusCode,
-  type ResumeStatusCode,
-} from "./constants.ts";
-
-// Transport interface
-export type {
-  Transport,
-  TransportOptions,
-  TlsOptions,
-  TransportEvents,
-  ReceivedMessage,
-} from "./transport.ts";
-
-// Frame decoder
-export { FrameDecoder } from "./frame-decoder.ts";
-
-// Transport implementations
-export { TlsTransport } from "./tls-transport.ts";
-export { TcpTransport } from "./tcp-transport.ts";
+/**
+ * @hla4ts/transport - HLA 4 Federate Protocol Transport Layer
+ *
+ * This package provides transport implementations for the HLA 4 Federate Protocol,
+ * including message framing, TLS support, and connection management.
+ *
+ * @example
+ * ```ts
+ * import { TlsTransport, MessageType, encodeMessage } from '@hla4ts/transport';
+ *
+ * // Create a TLS transport
+ * const transport = new TlsTransport({
+ *   host: 'rti.example.com',
+ *   port: 15165,
+ * });
+ *
+ * // Set up event handlers
+ * transport.setEventHandlers({
+ *   onMessage: (msg) => {
+ *     console.log('Received:', MessageType[msg.header.messageType]);
+ *   },
+ *   onClose: () => console.log('Connection closed'),
+ *   onError: (err) => console.error('Error:', err),
+ * });
+ *
+ * // Connect and send a message
+ * await transport.connect();
+ * const message = encodeMessage(
+ *   1,                              // sequence number
+ *   0n,                             // session ID (0 for new session)
+ *   0,                              // last received seq num
+ *   MessageType.CTRL_NEW_SESSION,   // message type
+ *   payload                         // optional payload
+ * );
+ * await transport.send(message);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Message types
+export { MessageType, isControlMessage, isHlaResponse, messageTypeName } from "./message-type.ts";
+
+// Message header encoding/decoding
+export {
+  HEADER_SIZE,
+  NO_SESSION_ID,
+  NO_SEQUENCE_NUMBER,
+  encodeHeader,
+  decodeHeader,
+  encodeMessage,
+  getPayloadSize,
+  type MessageHeader,
+} from "./message-header.ts";
+
+// Constants
+export {
+  FEDERATE_PROTOCOL_VERSION,
+  Ports,
+  Protocol,
+  NewSessionStatus,
+  ResumeStatus,
+  type ProtocolType,
+  type NewSessionStatusCode,
+  type ResumeStatusCode,
+} from "./constants.ts";
+
+// Transport interface
+export type {
+  Transport,
+  TransportOptions,
+  TlsOptions,
+  TransportEvents,
+  ReceivedMessage,
+} from "./transport.ts";
+
+// Frame decoder
+export { FrameDecoder } from "./frame-decoder.ts";
+
+// Transport implementations
+export { TlsTransport } from "./tls-transport.ts";
+export { TcpTransport } from "./tcp-transport.ts";