handleChannelFailure(channel, e);
                }
            }
            
            // Check error rate
            if (channel.getErrorRate() > 0.1) {
                log.warn("High error rate on channel {}: {}", 
                    channel.getChannelId(), channel.getErrorRate());
                // Consider removing channel
            }

     */
    public ChannelInfo getChannelForTransport(SmbTransport transport) {
        return channels.values().stream().filter(c -> c.getTransport() == transport).findFirst().orElse(null);
    }

    /**
     * Remove a channel
     *
     * @param channel channel to remove
     */
    public void removeChannel(ChannelInfo channel) {
        channels.remove(channel.getChannelId());

            return new ArrayList<>(channels);
        }

        public void addChannel(ChannelInfo channel) {
            channels.add(channel);
            if (primaryChannel == null) {
                primaryChannel = channel;
            }
        }

        public void removeChannel(ChannelInfo channel) {
            channels.remove(channel);

    private final AtomicLong errors;

    // Channel binding
    private byte[] bindingHash;
    private boolean isPrimary;

    // Pending operations
    private final List<CommonServerMessageBlock> pendingOperations;

    /**
     * Create channel information
     *
     * @param channelId unique channel identifier
     * @param transport SMB transport for this channel
     * @param localInterface local network interface

- [ ] Create channel synchronization mechanism
- [ ] Implement channel failure detection
- [ ] Add automatic channel recovery
- [ ] Create channel performance monitoring

#### 3.3 Integration Points
- Modify `SmbTransportPool` for multiple connections per session
- Update `SmbSession` for multi-channel awareness
- Enhance `SmbTransport` for channel management

---

### Phase 4: Directory Leasing

        } catch (Exception e) {
            log.warn("Failed to recover channel {}: {}", channel.getChannelId(), e.getMessage());

            // Schedule next retry or remove
            handleFailure(channel, e);
        }
    }

    private void removeChannel(ChannelInfo channel) {
        log.info("Removing failed channel {} after max retries", channel.getChannelId());

use a synchronization mechanism such as a lock or channel
communication to establish a relative ordering.
</p>

<h3 id="chan">Channel communication</h3>

<p>
Channel communication is the main method of synchronization
between goroutines.  Each send on a particular channel
is matched to a corresponding receive from that channel,
usually in a different goroutine.
</p>

<p class="rule">

func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after
// the last sent value is received. After the last value has been received
// from a closed channel c, any receive from c will succeed without

func (target *AMQPTarget) isActive() (bool, error) {
	ch, _, err := target.channel()
	if err != nil {
		return false, err
	}
	defer func() {
		ch.Close()
	}()
	return true, nil
}

func (target *AMQPTarget) channel() (*amqp091.Channel, chan amqp091.Confirmation, error) {
	var err error
	var conn *amqp091.Connection
	var ch *amqp091.Channel

	isAMQPClosedErr := func(err error) bool {

##### Figure 1 - Secure Channel construction

```