private byte[] calculateBindingHash(byte[] bindingInfo) throws IOException {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            return digest.digest(bindingInfo);
        } catch (NoSuchAlgorithmException e) {
            throw new IOException("SHA-256 not available", e);
        }
    }

    private void performHealthCheck() {
        for (ChannelInfo channel : channels.values()) {

        ContentOutputStream cos = new ContentOutputStream(100, Curl.tmpDir);
        byte[] largeData = new byte[500];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        cos.write(largeData);
        assertFalse(cos.isInMemory());
        File file = cos.getFile();
        assertTrue(file.exists());
        assertEquals(500, file.length());

            return; // Skip sizes larger than buffer
        }

        byte[] sourceData = new byte[dataSize];
        for (int i = 0; i < dataSize; i++) {
            sourceData[i] = (byte) (i % 256);
        }

        byte[] buffer = new byte[dataSize + 50];
        System.arraycopy(sourceData, 0, buffer, 10, dataSize);

        int result = response.readDataWireFormat(buffer, 10, dataSize);

    val symbol: Int

    /** Number of bits represented in the terminal node. */
    val terminalBitCount: Int

    /** Construct an internal node. */
    constructor() {
      this.children = arrayOfNulls(256)
      this.symbol = 0 // Not read.
      this.terminalBitCount = 0 // Not read.
    }

    /** Construct a terminal node. */
    constructor(symbol: Int, bits: Int) {
      this.children = null

        }
    }

    /**
     * Counts the number of unique bytes in the data (for entropy estimation).
     */
    private int countUniqueBytes(byte[] data) {
        boolean[] seen = new boolean[256];
        int count = 0;

        for (byte b : data) {
            int index = b & 0xFF;
            if (!seen[index]) {
                seen[index] = true;
                count++;
            }

        assertEquals((byte) (value & 0xFF), dst[3]);
    }

    private static Stream<Arguments> provideInt4TestValues() {
        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")

    void testMaxOffsetBoundary() {
        // Arrange
        byte[] largeData = new byte[1000];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        int offset = 990;
        int length = 10;

        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, largeData, offset, length);
        byte[] dst = new byte[100];

            this.preauthSalt = salt;

            if (config.isEncryptionEnabled()) {
                // Build cipher list based on AES-256 support
                List<Integer> ciphers = new ArrayList<>();

                // Prefer GCM over CCM for better performance
                if (config.isAES256Enabled()) {

        if (context != null) {
            System.arraycopy(context, 0, input, pos, context.length);
        }

        // Use SHA-256 for derivation (placeholder)
        try {
            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
            byte[] hash = md.digest(input);
            System.arraycopy(hash, 0, derived, 0, Math.min(length, hash.length));

  - [Changelog since v1.28.6](#changelog-since-v1286)
  - [Changes by Kind](#changes-by-kind-8)
    - [Feature](#feature-6)
    - [Bug or Regression](#bug-or-regression-8)
  - [Dependencies](#dependencies-8)
    - [Added](#added-8)
    - [Changed](#changed-8)
    - [Removed](#removed-8)
- [v1.28.6](#v1286)
  - [Downloads for v1.28.6](#downloads-for-v1286)
    - [Source Code](#source-code-9)