@arcanewizards/tcnet 0.1.1

package/dist/chunk-FAJ3XTSE.js

@@ -0,0 +1,435 @@
+import {
+  TCNetError,
+  TCNetProtocolError
+} from "./chunk-VXAKTGOW.js";
+
+// src/protocol.ts
+var TCNET_LAYER_COUNT = 8;
+var TCNET_LAYER_STATE_IDS = Object.freeze({
+  IDLE: 0,
+  /**
+   * Not in spec, but seems to be what's observed.
+   */
+  LOADING: 2,
+  PLAYING: 3,
+  LOOPING: 4,
+  PAUSED: 5,
+  STOPPED: 6,
+  CUEDOWN: 7,
+  PLATTERDOWN: 8,
+  FFWD: 9,
+  FFRV: 10,
+  HOLD: 11,
+  /**
+   * Not in spec, but seems to be what's observed.
+   */
+  END: 17,
+  /**
+   * TODO: determine what this means, seems to be disconnected state?
+   */
+  UNKNOWN: 255
+});
+var TCNET_LAYER_STATES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_LAYER_STATE_IDS).map(([key, value]) => [
+      value,
+      key
+    ])
+  )
+);
+var getTcNetLayerState = (id) => {
+  const state = TCNET_LAYER_STATES[id];
+  if (!state) {
+    throw new TCNetProtocolError(`Unknown TCNet layer state: ${id}`);
+  }
+  return state;
+};
+var TCNET_MIXER_TYPE_IDS = Object.freeze({
+  STANDARD: 0,
+  EXTENDED: 2
+});
+var TCNET_MIXER_TYPES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_MIXER_TYPE_IDS).map(([key, value]) => [
+      value,
+      key
+    ])
+  )
+);
+var getTcNetMixerType = (id) => {
+  const type = TCNET_MIXER_TYPES[id];
+  if (!type) {
+    throw new TCNetProtocolError(`Unknown TCNet mixer type: ${id}`);
+  }
+  return type;
+};
+var TCNET_MESSAGE_TYPE_IDS = Object.freeze({
+  OPT_IN: 2,
+  OPT_OUT: 3,
+  STATUS: 5,
+  TIME_SYNC: 10,
+  ERROR: 13,
+  REQUEST: 20,
+  APPLICATION_SPECIFIC_DATA_1: 30,
+  CONTROL: 101,
+  TEXT_DATA: 128,
+  KEYBOARD_DATA: 132,
+  DATA: 200,
+  FILE: 204,
+  APPLICATION_SPECIFIC_DATA_2: 213,
+  TIME: 254
+});
+var TCNET_MESSAGE_TYPES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_MESSAGE_TYPE_IDS).map(([key, value]) => [value, key])
+  )
+);
+var getTcNetMessageType = (id) => {
+  const type = TCNET_MESSAGE_TYPES[id];
+  if (!type) {
+    throw new TCNetProtocolError(`Unknown TCNet message type: ${id}`);
+  }
+  return type;
+};
+var TCNET_DATA_PACKET_TYPE_IDS = Object.freeze({
+  METRICS_DATA: 2,
+  METADATA: 4,
+  BEAT_GRID_DATA: 8,
+  CUE_DATA: 12,
+  SMALL_WAVEFORM: 16,
+  BIG_WAVEFORM: 32,
+  MIXER_DATA: 150
+});
+var TCNET_DATA_PACKET_TYPES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_DATA_PACKET_TYPE_IDS).map(([key, value]) => [
+      value,
+      key
+    ])
+  )
+);
+var getTcNetDataPacketType = (id) => {
+  const type = TCNET_DATA_PACKET_TYPES[id];
+  if (!type) {
+    throw new TCNetProtocolError(`Unknown TCNet data packet type: ${id}`);
+  }
+  return type;
+};
+var TCNET_NODE_TYPE_IDS = Object.freeze({
+  AUTO: 1,
+  MASTER: 2,
+  SLAVE: 4,
+  REPEATER: 8
+});
+var TCNET_NODE_TYPES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_NODE_TYPE_IDS).map(([key, value]) => [value, key])
+  )
+);
+var getTcNetNodeType = (id) => {
+  const type = TCNET_NODE_TYPES[id];
+  if (!type) {
+    throw new TCNetProtocolError(`Unknown TCNet node type: ${id}`);
+  }
+  return type;
+};
+var TCNET_PORT_NODE_OPTION_FLAGS = Object.freeze({
+  NEED_AUTHENTICATION: 1,
+  /**
+   * Listens to TCNet Control Messages
+   */
+  SUPPORTS_TCNCM: 2,
+  /**
+   * Listens to TCNet Application Specific Data Packets
+   */
+  SUPPORTS_TCNASDP: 4,
+  /**
+   * Do not disturb/Sleeping. Node will request data itself if needed to avoid traffic
+   */
+  DO_NOT_DISTURB: 8
+});
+var parseTcNetPortNodeOptions = (flags) => {
+  return Object.fromEntries(
+    Object.entries(TCNET_PORT_NODE_OPTION_FLAGS).map(([key, flag]) => [
+      key,
+      (flags & flag) !== 0 ? true : void 0
+    ])
+  );
+};
+var generateTcNetPortNodeOptionsFlags = (options) => {
+  let flags = 0;
+  for (const [option, value] of Object.entries(options)) {
+    if (value) {
+      const flag = TCNET_PORT_NODE_OPTION_FLAGS[option];
+      flags |= flag;
+    }
+  }
+  return flags;
+};
+var TCNET_LAYER_TC_STATE_IDS = Object.freeze({
+  STOPPED: 0,
+  RUNNING: 1,
+  FORCE_RESYNC: 2
+});
+var TCNET_LAYER_TC_STATES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TCNET_LAYER_TC_STATE_IDS).map(([key, value]) => [
+      value,
+      key
+    ])
+  )
+);
+var getTcNetLayerTCState = (id) => {
+  const state = TCNET_LAYER_TC_STATES[id];
+  if (!state) {
+    throw new TCNetProtocolError(`Unknown TCNet layer timecode state: ${id}`);
+  }
+  return state;
+};
+var MAX_NODE_ID = 256 * 256 - 1;
+var MGMT_HEADER_VERSION = 3;
+var MGMT_HEADER_MINOR_VERSION = 5;
+var MGMT_MAGIC_HEADER = "TCN";
+var writeManagementHeader = (buffer, header, messageType) => {
+  buffer.writeUInt16LE(header.nodeId, 0);
+  buffer.writeUInt8(header.protocolVersionMajor, 2);
+  buffer.writeUInt8(header.protocolVersionMinor, 3);
+  buffer.write(MGMT_MAGIC_HEADER, 4, "ascii");
+  buffer.writeUInt8(TCNET_MESSAGE_TYPE_IDS[messageType], 7);
+  header.nodeName.copy(buffer, 8, 0, 8);
+  buffer.writeUInt8(header.seq, 16);
+  buffer.writeUInt8(TCNET_NODE_TYPE_IDS[header.nodeType], 17);
+  buffer.writeUInt16LE(
+    generateTcNetPortNodeOptionsFlags(header.nodeOptions),
+    18
+  );
+  buffer.writeUInt32LE(header.timestamp, 20);
+};
+var parseManagementHeader = (buffer) => {
+  const magicHeader = buffer.toString("ascii", 4, 7);
+  if (magicHeader !== MGMT_MAGIC_HEADER) {
+    throw new TCNetProtocolError(
+      `Invalid management header magic: ${magicHeader}`
+    );
+  }
+  return {
+    nodeId: buffer.readUInt16LE(0),
+    protocolVersionMajor: buffer.readUInt8(2),
+    protocolVersionMinor: buffer.readUInt8(3),
+    messageType: getTcNetMessageType(buffer.readUInt8(7)),
+    nodeName: buffer.subarray(8, 16),
+    seq: buffer.readUInt8(16),
+    nodeType: getTcNetNodeType(buffer.readUInt8(17)),
+    nodeOptions: parseTcNetPortNodeOptions(buffer.readUInt16LE(18)),
+    timestamp: buffer.readUInt32LE(20)
+  };
+};
+var writeOptInPacket = (data) => {
+  const buffer = Buffer.alloc(68);
+  writeManagementHeader(buffer, data.header, "OPT_IN");
+  buffer.writeUInt16LE(data.nodeCount, 24);
+  buffer.writeUInt16LE(data.nodeListenerPort, 26);
+  buffer.writeUInt16LE(data.uptime, 28);
+  data.vendorName.copy(buffer, 32, 0, 16);
+  data.applicationName.copy(buffer, 48, 0, 16);
+  data.applicationVersion.copy(buffer, 64, 0, 3);
+  return buffer;
+};
+var parseOptInPacket = (header, buffer) => {
+  return {
+    header,
+    type: "OPT_IN",
+    nodeCount: buffer.readUInt16LE(24),
+    nodeListenerPort: buffer.readUInt16LE(26),
+    uptime: buffer.readUInt16LE(28),
+    vendorName: buffer.subarray(32, 48),
+    applicationName: buffer.subarray(48, 64),
+    applicationVersion: buffer.subarray(64, 67)
+  };
+};
+var writeOptOutPacket = (data) => {
+  const buffer = Buffer.alloc(28);
+  writeManagementHeader(buffer, data.header, "OPT_OUT");
+  buffer.writeUInt16LE(data.nodeCount, 24);
+  buffer.writeUInt16LE(data.nodeListenerPort, 26);
+  return buffer;
+};
+var parseOptOutPacket = (header, buffer) => {
+  return {
+    header,
+    type: "OPT_OUT",
+    nodeCount: buffer.readUInt16LE(24),
+    nodeListenerPort: buffer.readUInt16LE(26)
+  };
+};
+var parseStatusPacket = (header, buffer) => {
+  const nodeCount = buffer.readUInt16LE(24);
+  const nodeListenerPort = buffer.readUInt16LE(26);
+  const smpteMode = buffer.readUInt8(83);
+  const autoMasterMode = buffer.readUInt8(84);
+  const layers = new Array(8);
+  for (let n = 0; n < 8; n++) {
+    layers[n] = {
+      source: buffer.readUInt8(34 + n),
+      status: getTcNetLayerState(buffer.readUInt8(42 + n)),
+      trackId: buffer.readUInt32LE(50 + n * 4),
+      name: buffer.slice(172 + n * 16, 172 + (n + 1) * 16).toString("ascii").replace(/\0/g, "")
+    };
+  }
+  return {
+    header,
+    type: "STATUS",
+    nodeCount,
+    nodeListenerPort,
+    smpteMode,
+    autoMasterMode,
+    layers
+  };
+};
+var writeRequestPacket = (data) => {
+  const buffer = Buffer.alloc(26);
+  writeManagementHeader(buffer, data.header, "REQUEST");
+  buffer.writeUInt8(TCNET_DATA_PACKET_TYPE_IDS[data.dataType], 24);
+  buffer.writeUInt8(data.layer, 25);
+  return buffer;
+};
+var parseApplicationSpecificData1Packet = (header, _buffer) => {
+  return {
+    header,
+    type: "APPLICATION_SPECIFIC_DATA_1"
+  };
+};
+var parseMetricsDataPacket = (header, buffer) => {
+  return {
+    header,
+    type: "DATA",
+    dataType: "METRICS_DATA",
+    layer: buffer.readUInt8(25),
+    state: getTcNetLayerState(buffer.readUInt8(27)),
+    syncMaster: buffer.readUInt8(29),
+    beatMarker: buffer.readUInt8(31),
+    trackLengthMillis: buffer.readUInt32LE(32),
+    currentPositionMillis: buffer.readUInt32LE(36),
+    speed: buffer.readUInt32LE(40),
+    beatNumber: buffer.readUInt32LE(57),
+    bpm: buffer.readUInt32LE(112),
+    pitchBend: buffer.readInt16LE(116),
+    trackId: buffer.readUInt32LE(118)
+  };
+};
+var parseMetadataDataPacket = (header, buffer) => {
+  const encoding = header.protocolVersionMajor >= 3 && header.protocolVersionMinor >= 5 ? "utf16le" : "utf-8";
+  return {
+    header,
+    type: "DATA",
+    dataType: "METADATA",
+    layer: buffer.readUInt8(25),
+    trackArtist: buffer.toString(encoding, 29, 285).replace(/\0/g, ""),
+    trackTitle: buffer.toString(encoding, 285, 541).replace(/\0/g, ""),
+    trackKey: buffer.readUInt16LE(541),
+    trackId: buffer.readUInt32LE(543)
+  };
+};
+var parseMixerDataPacket = (header, buffer) => {
+  return {
+    header,
+    type: "DATA",
+    dataType: "MIXER_DATA",
+    mixerId: buffer.readUInt8(25),
+    mixerType: getTcNetMixerType(buffer.readUInt8(26)),
+    mixerName: buffer.toString("ascii", 29, 45).replace(/\0/g, ""),
+    micEqHi: buffer.readUInt8(59),
+    micEqLow: buffer.readUInt8(60),
+    masterAudioLevel: buffer.readUInt8(61),
+    masterFaderLevel: buffer.readUInt8(62)
+  };
+};
+var parseDataPacket = (header, buffer) => {
+  const dataType = getTcNetDataPacketType(buffer.readUInt8(24));
+  if (dataType === "METRICS_DATA") {
+    return parseMetricsDataPacket(header, buffer);
+  } else if (dataType === "MIXER_DATA") {
+    return parseMixerDataPacket(header, buffer);
+  } else if (dataType === "METADATA") {
+    return parseMetadataDataPacket(header, buffer);
+  }
+  throw new TCNetError(`Library support for ${dataType} not implemented`);
+};
+var parseSMPTEFramerate = (framerate) => {
+  if (framerate === 24 || framerate === 25 || framerate === 29 || framerate === 30) {
+    return framerate;
+  }
+  throw new TCNetProtocolError(`Unknown SMPTE framerate: ${framerate}`);
+};
+var parseTimePacket = (header, buffer) => {
+  const layers = new Array(8);
+  for (let i = 0; i < 8; i++) {
+    const smpteMode = buffer.readUInt8(106 + i * 6);
+    layers[i] = {
+      currentTimeMillis: buffer.readUInt32LE(24 + i * 4),
+      totalTimeMillis: buffer.readUInt32LE(56 + i * 4),
+      beatMarker: buffer.readUInt8(88 + i),
+      state: getTcNetLayerState(buffer.readUInt8(96 + i)),
+      smpte: {
+        /**
+         * Spec says 0 here, but ShowKontrol seems to also be sending 1.
+         */
+        mode: smpteMode === 0 || smpteMode === 1 ? null : parseSMPTEFramerate(smpteMode),
+        state: getTcNetLayerTCState(buffer.readUInt8(107 + i * 6)),
+        hours: buffer.readUInt8(108 + i * 6),
+        minutes: buffer.readUInt8(109 + i * 6),
+        seconds: buffer.readUInt8(110 + i * 6),
+        frames: buffer.readUInt8(111 + i * 6)
+      },
+      onAir: buffer.length > 154 ? buffer.readUInt8(154 + i) : 255
+    };
+  }
+  return {
+    header,
+    type: "TIME",
+    layers,
+    generalSmpteFramerate: parseSMPTEFramerate(buffer.readUInt8(105))
+  };
+};
+var parsePacket = (buffer) => {
+  const header = parseManagementHeader(buffer);
+  switch (header.messageType) {
+    case "OPT_IN":
+      return parseOptInPacket(header, buffer);
+    case "OPT_OUT":
+      return parseOptOutPacket(header, buffer);
+    case "STATUS":
+      return parseStatusPacket(header, buffer);
+    case "DATA":
+      return parseDataPacket(header, buffer);
+    case "APPLICATION_SPECIFIC_DATA_1":
+      return parseApplicationSpecificData1Packet(header, buffer);
+    case "TIME":
+      return parseTimePacket(header, buffer);
+    default:
+      throw new TCNetError(
+        `Library support for ${header.messageType} not implemented`
+      );
+  }
+};
+
+export {
+  TCNET_LAYER_COUNT,
+  getTcNetLayerState,
+  getTcNetMixerType,
+  getTcNetMessageType,
+  getTcNetDataPacketType,
+  getTcNetNodeType,
+  parseTcNetPortNodeOptions,
+  generateTcNetPortNodeOptionsFlags,
+  getTcNetLayerTCState,
+  MAX_NODE_ID,
+  MGMT_HEADER_VERSION,
+  MGMT_HEADER_MINOR_VERSION,
+  writeManagementHeader,
+  parseManagementHeader,
+  writeOptInPacket,
+  writeOptOutPacket,
+  writeRequestPacket,
+  parsePacket
+};

package/dist/chunk-VRXVI5VA.cjs

@@ -0,0 +1,86 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkVYNI4G3Kcjs = require('./chunk-VYNI4G3K.cjs');
+
+// src/utils.ts
+var differsByMoreThan = (a, b, diff) => {
+  return Math.abs(a - b) > diff;
+};
+var MAX_NODE_NAME_LENGTH = 8;
+var MAX_VENDOR_NAME_LENGTH = 16;
+var MAX_APPLICATION_NAME_LENGTH = 16;
+var generateProtocolStrings = ({
+  nodeName,
+  vendorName,
+  appName
+}) => {
+  const strings = {
+    nodeName: Buffer.from(
+      nodeName.padEnd(MAX_NODE_NAME_LENGTH, "\0"),
+      "ascii"
+    ),
+    vendorName: Buffer.from(
+      vendorName.padEnd(MAX_VENDOR_NAME_LENGTH, "\0"),
+      "ascii"
+    ),
+    appName: Buffer.from(
+      appName.padEnd(MAX_APPLICATION_NAME_LENGTH, "\0"),
+      "ascii"
+    )
+  };
+  if (strings.nodeName.length > MAX_NODE_NAME_LENGTH) {
+    throw new (0, _chunkVYNI4G3Kcjs.TCNetConfigurationError)(
+      `Node name "${nodeName}" exceeds maximum length of ${MAX_NODE_NAME_LENGTH} ASCII characters`
+    );
+  }
+  if (strings.vendorName.length > MAX_VENDOR_NAME_LENGTH) {
+    throw new (0, _chunkVYNI4G3Kcjs.TCNetConfigurationError)(
+      `Vendor name "${vendorName}" exceeds maximum length of ${MAX_VENDOR_NAME_LENGTH} ASCII characters`
+    );
+  }
+  if (strings.appName.length > MAX_APPLICATION_NAME_LENGTH) {
+    throw new (0, _chunkVYNI4G3Kcjs.TCNetConfigurationError)(
+      `Application name "${appName}" exceeds maximum length of ${MAX_APPLICATION_NAME_LENGTH} ASCII characters`
+    );
+  }
+  return strings;
+};
+var generateApplicationVersion = (version) => {
+  const [major, minor, bug] = version.split(".").map((part) => parseInt(part));
+  if (major === void 0 || minor === void 0 || bug === void 0 || isNaN(major) || isNaN(minor) || isNaN(bug) || major < 0 || minor < 0 || bug < 0 || major > 255 || minor > 255 || bug > 255) {
+    throw new (0, _chunkVYNI4G3Kcjs.TCNetConfigurationError)(
+      `Invalid application version "${version}". Must be in format "major.minor.bug" with each part between 0 and 255.`
+    );
+  }
+  const buffer = Buffer.alloc(3);
+  buffer.writeUInt8(major, 0);
+  buffer.writeUInt8(minor, 1);
+  buffer.writeUInt8(bug, 2);
+  return buffer;
+};
+var parseApplicationVersion = (buffer) => {
+  if (buffer.length !== 3) {
+    throw new (0, _chunkVYNI4G3Kcjs.TCNetConfigurationError)(
+      `Invalid application version buffer length ${buffer.length}. Must be exactly 3 bytes.`
+    );
+  }
+  const major = buffer.readUInt8(0);
+  const minor = buffer.readUInt8(1);
+  const bug = buffer.readUInt8(2);
+  return `${major}.${minor}.${bug}`;
+};
+var getNodeDescription = (info) => {
+  return `${info.nodeName} (${info.appName} ${info.appVersion}) - ${info.host}:${info.nodeListenerPort} (${info.nodeType})`;
+};
+var calculateUniqueNodeId = (info) => {
+  return `${info.host}:${info.nodeId}`;
+};
+
+
+
+
+
+
+
+
+exports.differsByMoreThan = differsByMoreThan; exports.generateProtocolStrings = generateProtocolStrings; exports.generateApplicationVersion = generateApplicationVersion; exports.parseApplicationVersion = parseApplicationVersion; exports.getNodeDescription = getNodeDescription; exports.calculateUniqueNodeId = calculateUniqueNodeId;

package/dist/chunk-VXAKTGOW.js

@@ -0,0 +1,70 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/errors.ts
+var TCNetError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "TCNetError";
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var TCNetInitializationError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetInitializationError";
+  }
+};
+var TCNetConfigurationError = class extends TCNetError {
+  constructor(message) {
+    super(message);
+    this.name = "TCNetConfigurationError";
+  }
+};
+var TCNetProtocolError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetProtocolError";
+  }
+};
+var TCNetNetworkError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetNetworkError";
+  }
+};
+
+export {
+  __commonJS,
+  __toESM,
+  TCNetError,
+  TCNetInitializationError,
+  TCNetConfigurationError,
+  TCNetProtocolError,
+  TCNetNetworkError
+};

package/dist/chunk-VYNI4G3K.cjs

@@ -0,0 +1,70 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/errors.ts
+var TCNetError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "TCNetError";
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+};
+var TCNetInitializationError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetInitializationError";
+  }
+};
+var TCNetConfigurationError = class extends TCNetError {
+  constructor(message) {
+    super(message);
+    this.name = "TCNetConfigurationError";
+  }
+};
+var TCNetProtocolError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetProtocolError";
+  }
+};
+var TCNetNetworkError = class extends TCNetError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TCNetNetworkError";
+  }
+};
+
+
+
+
+
+
+
+
+
+exports.__commonJS = __commonJS; exports.__toESM = __toESM; exports.TCNetError = TCNetError; exports.TCNetInitializationError = TCNetInitializationError; exports.TCNetConfigurationError = TCNetConfigurationError; exports.TCNetProtocolError = TCNetProtocolError; exports.TCNetNetworkError = TCNetNetworkError;

package/dist/errors.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkVYNI4G3Kcjs = require('./chunk-VYNI4G3K.cjs');
+
+
+
+
+
+
+exports.TCNetConfigurationError = _chunkVYNI4G3Kcjs.TCNetConfigurationError; exports.TCNetError = _chunkVYNI4G3Kcjs.TCNetError; exports.TCNetInitializationError = _chunkVYNI4G3Kcjs.TCNetInitializationError; exports.TCNetNetworkError = _chunkVYNI4G3Kcjs.TCNetNetworkError; exports.TCNetProtocolError = _chunkVYNI4G3Kcjs.TCNetProtocolError;

package/dist/errors.d.cts

@@ -0,0 +1,17 @@
+declare class TCNetError extends Error {
+    constructor(message: string, cause?: Error);
+}
+declare class TCNetInitializationError extends TCNetError {
+    constructor(message: string, cause: Error);
+}
+declare class TCNetConfigurationError extends TCNetError {
+    constructor(message: string);
+}
+declare class TCNetProtocolError extends TCNetError {
+    constructor(message: string, cause?: Error);
+}
+declare class TCNetNetworkError extends TCNetError {
+    constructor(message: string, cause?: Error);
+}
+
+export { TCNetConfigurationError, TCNetError, TCNetInitializationError, TCNetNetworkError, TCNetProtocolError };