Class Channel

constructor

• new Channel(outlet: ChannelOutletBase): Channel

  Parameters

  • outlet: ChannelOutletBase

  Returns Channel

_maxTries

_messageCallbacks

_messageFactories

_nextRxSequence

_nextSequence

_outlet

_rxRing

_sendChain

_shutDown

_txRing

fastRateRounds

mediumRateRounds

window

windowFlexibility

windowMax

windowMin

mdu

• get mdu(): number

  Maximum body bytes available to a single message: the outlet MDU minus the 6-byte envelope header, capped at 16 bits.

  Returns number

StaticSEQ_MAX

• get SEQ_MAX(): number

  Largest sequence number (16-bit).

  Returns number

StaticSEQ_MODULUS

• get SEQ_MODULUS(): number

  Sequence-number modulus (0x10000).

  Returns number

_receive

• _receive(raw: Uint8Array<ArrayBufferLike>): void

  Decode an inbound envelope, validate its sequence, accept it into the rx ring, and deliver any newly-contiguous messages to handlers in order.

  Parameters

  • raw: Uint8Array<ArrayBufferLike>

  Returns void

_registerSystemMessageType

• _registerSystemMessageType(messageClass: typeof MessageBase): void

  Register a system message type (MSGTYPE >= 0xf000). Library use only (e.g. the Buffer stream layer's StreamDataMessage).

  Parameters

  • messageClass: typeof MessageBase

  Returns void

_shutdown

• _shutdown(): void

  Tear the channel down: clear handlers, rings, and outlet timers/callbacks. Called on link teardown and on retry-count exhaustion.

  Returns void

addMessageHandler

• addMessageHandler(callback: (message: MessageBase) => boolean): void

  Add a handler for incoming messages. Handlers are invoked in insertion order; if one returns true, processing stops (later handlers are skipped).

  Parameters

  • callback: (message: MessageBase) => boolean

  Returns void

isReadyToSend

• isReadyToSend(): boolean

  Whether the channel can accept another send.

  Returns boolean

openDuplex

• openDuplex(
      receiveStreamId: number,
      sendStreamId: number,
      options?: { bz2?: any },
  ): {
      readable: ReadableStream<Uint8Array<ArrayBufferLike>>;
      writable: WritableStream<Uint8Array<ArrayBufferLike>>;
  }

  Open a duplex { readable, writable } pair over this channel: readable receives receiveStreamId, writable sends sendStreamId. See openReadable / openWritable for compression / backpressure.

  Parameters

  • receiveStreamId: number

    local stream id to receive at.

  • sendStreamId: number

    remote stream id to send to.

  • Optionaloptions: { bz2?: any }

    override the link's injected bz2.

  Returns {
      readable: ReadableStream<Uint8Array<ArrayBufferLike>>;
      writable: WritableStream<Uint8Array<ArrayBufferLike>>;
  }

openReadable

• openReadable(
      streamId: number,
      options?: { bz2?: any },
  ): ReadableStream<Uint8Array<ArrayBufferLike>>

  Open a ReadableStream<Uint8Array> that receives byte-stream frames addressed to streamId. Registers StreamDataMessage as a system type and a per-stream handler; the stream closes once an eof frame has been delivered.

  Compression: a bz2 module injected on the link (link.bz2, the same field Resources use) decompresses inbound frames; without it a compressed frame errors the stream.

  Parameters

  • streamId: number

    local stream id to receive at (0–0x3fff).

  • Optionaloptions: { bz2?: any }

    override the link's injected bz2.

  Returns ReadableStream<Uint8Array<ArrayBufferLike>>

openWritable

• openWritable(
      streamId: number,
      options?: { bz2?: any },
  ): WritableStream<Uint8Array<ArrayBufferLike>>

  Open a WritableStream<Uint8Array> that sends byte-stream frames to the peer's streamId. Each written chunk is split into StreamDataMessage- sized frames; backpressure follows the channel send window. close() sends a final eof frame.

  Compression: when a bz2 module is available (via options.bz2 or link.bz2), each frame is compressed only when compression actually shrinks it.

  Parameters

  • streamId: number

    remote stream id to send to (0–0x3fff).

  • Optionaloptions: { bz2?: any }

    override the link's injected bz2.

  Returns WritableStream<Uint8Array<ArrayBufferLike>>

registerMessageType

• registerMessageType(messageClass: typeof MessageBase): void

  Register a message class for reception. It must extend MessageBase, declare a valid MSGTYPE (< 0xf000), and be constructable with no args.

  Parameters

  • messageClass: typeof MessageBase

  Returns void

removeMessageHandler

• removeMessageHandler(callback: (message: MessageBase) => boolean): void

  Remove a handler added with addMessageHandler.

  Parameters

  • callback: (message: MessageBase) => boolean

  Returns void

send

• send(message: MessageBase): Promise<Envelope>

  Send a message reliably. Rejects if the channel is not ready (CEType.ME_LINK_NOT_READY) or the packed message exceeds the MDU (CEType.ME_TOO_BIG). Resolves with the outbound Envelope.

  Parameters

  • message: MessageBase

  Returns Promise<Envelope>