Merge pull request #5 from dolonet/sync-upstream-and-fix-module-path

Sync upstream + fix module path for go install

.codecov.yml

 ---
 
 fixes:
-  - "github.com/9seconds/mtg/v2/::"
+  - "github.com/dolonet/mtg-multi/::"

antireplay/noop.go

 package antireplay
 
-import "github.com/9seconds/mtg/v2/mtglib"
+import "github.com/dolonet/mtg-multi/mtglib"
 
 type noop struct{}
 

antireplay/noop_test.go

 import (
 	"testing"
 
-	"github.com/9seconds/mtg/v2/antireplay"
+	"github.com/dolonet/mtg-multi/antireplay"
 	"github.com/stretchr/testify/suite"
 )
 

antireplay/stable_bloom_filter.go

 import (
 	"sync"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/OneOfOne/xxhash"
 	boom "github.com/tylertreat/BoomFilters"
 )

antireplay/stable_bloom_filter_test.go

 import (
 	"testing"
 
-	"github.com/9seconds/mtg/v2/antireplay"
+	"github.com/dolonet/mtg-multi/antireplay"
 	"github.com/stretchr/testify/suite"
 )
 
 }
 
 func (suite *StableBloomFilterTestSuite) TestOp() {
-	filter := antireplay.NewStableBloomFilter(500, 0.001)
+	filter := antireplay.NewStableBloomFilter(100000, 0.001)
 
 	suite.False(filter.SeenBefore([]byte{1, 2, 3}))
 	suite.False(filter.SeenBefore([]byte{4, 5, 6}))

events/event_stream.go

 	"math/rand/v2"
 	"runtime"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/OneOfOne/xxhash"
 )
 

events/event_stream_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/events"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/events"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

events/init.go

 // EventStart for that session yet.
 package events
 
-import "github.com/9seconds/mtg/v2/mtglib"
+import "github.com/dolonet/mtg-multi/mtglib"
 
 // Observer is an instance that listens for the incoming events.
 //

events/init_test.go

 package events_test
 
 import (
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/stretchr/testify/mock"
 )
 

events/multi_observer.go

 import (
 	"sync"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type multiObserver struct {

events/noop.go

 import (
 	"context"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type noop struct{}

events/noop_test.go

 	"net"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/events"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/events"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/stretchr/testify/suite"
 )
 

go.mod

-module github.com/9seconds/mtg/v2
+module github.com/dolonet/mtg-multi
 
 go 1.26
 

internal/cli/access.go

 	"strconv"
 	"sync"
 
-	"github.com/9seconds/mtg/v2/internal/config"
-	"github.com/9seconds/mtg/v2/internal/utils"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/internal/config"
+	"github.com/dolonet/mtg-multi/internal/utils"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type accessResponseSecret struct {

internal/cli/doctor.go

 	"text/template"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/internal/config"
-	"github.com/9seconds/mtg/v2/internal/utils"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/network/v2"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/internal/config"
+	"github.com/dolonet/mtg-multi/internal/utils"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/network/v2"
 	"github.com/beevik/ntp"
 )
 

internal/cli/generate_secret.go

 import (
 	"fmt"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type GenerateSecret struct {

internal/cli/run.go

 import (
 	"fmt"
 
-	"github.com/9seconds/mtg/v2/internal/utils"
+	"github.com/dolonet/mtg-multi/internal/utils"
 )
 
 type Run struct {

internal/cli/run_proxy.go

 	"os"
 	"time"
 
-	"github.com/9seconds/mtg/v2/antireplay"
-	"github.com/9seconds/mtg/v2/events"
-	"github.com/9seconds/mtg/v2/internal/config"
-	"github.com/9seconds/mtg/v2/internal/proxyprotocol"
-	"github.com/9seconds/mtg/v2/internal/utils"
-	"github.com/9seconds/mtg/v2/ipblocklist"
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
-	"github.com/9seconds/mtg/v2/logger"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/network/v2"
-	"github.com/9seconds/mtg/v2/stats"
+	"github.com/dolonet/mtg-multi/antireplay"
+	"github.com/dolonet/mtg-multi/events"
+	"github.com/dolonet/mtg-multi/internal/config"
+	"github.com/dolonet/mtg-multi/internal/proxyprotocol"
+	"github.com/dolonet/mtg-multi/internal/utils"
+	"github.com/dolonet/mtg-multi/ipblocklist"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/logger"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/network/v2"
+	"github.com/dolonet/mtg-multi/stats"
 	"github.com/pires/go-proxyproto"
 	"github.com/rs/zerolog"
 	"github.com/yl2chen/cidranger"

internal/cli/simple_run.go

 	"strconv"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 )
 
 type SimpleRun struct {

internal/cli/utils.go

 	"net/http"
 	"strings"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 func getIP(ntw mtglib.Network, protocol string) net.IP {

internal/config/config.go

 	"net"
 	"net/url"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type Optional struct {
 		Blocklist    ListConfig `json:"blocklist"`
 		Allowlist    ListConfig `json:"allowlist"`
 		Doppelganger struct {
-			URLs            []TypeHttpsURL  `json:"urls"`
-			Repeats         TypeConcurrency `json:"repeats_per_raid"`
-			UpdateEach      TypeDuration    `json:"raid_each"`
-			DRS             TypeBool        `json:"drs"`
+			URLs       []TypeHttpsURL  `json:"urls"`
+			Repeats    TypeConcurrency `json:"repeats_per_raid"`
+			UpdateEach TypeDuration    `json:"raid_each"`
+			DRS        TypeBool        `json:"drs"`
 		} `json:"doppelganger"`
 	} `json:"defense"`
 	Network struct {

internal/config/config_test.go

 	"path/filepath"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/suite"
 )
 

internal/config/parse.go

 			UpdateEach          string   `toml:"update-each" json:"updateEach,omitempty"`
 		} `toml:"allowlist" json:"allowlist,omitempty"`
 		Doppelganger struct {
-			URLs            []string `toml:"urls" json:"urls,omitempty"`
-			Repeats         uint     `toml:"repeats-per-raid" json:"repeats_per_raid,omitempty"`
-			UpdateEach      string   `toml:"raid-each" json:"raid_each,omitempty"`
-			DRS             bool     `toml:"drs" json:"drs,omitempty"`
+			URLs       []string `toml:"urls" json:"urls,omitempty"`
+			Repeats    uint     `toml:"repeats-per-raid" json:"repeats_per_raid,omitempty"`
+			UpdateEach string   `toml:"raid-each" json:"raid_each,omitempty"`
+			DRS        bool     `toml:"drs" json:"drs,omitempty"`
 		} `toml:"doppelganger" json:"doppelganger,omitempty"`
 	} `toml:"defense" json:"defense,omitempty"`
 	Network struct {

internal/config/type_blocklist_uri_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_bool_test.go

 	"strconv"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_bytes_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_concurrency_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_dc_test.go

 	"strconv"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_dns_uri_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_duration_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_error_rate_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_hostport_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_http_path_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_https_url_test.go

 	"net/url"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_ip_test.go

 	"net"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_metric_prefix_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_port_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_prefer_ip_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_proxy_url_test.go

 	"net/url"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/config/type_statsd_tag_format_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

internal/testlib/mtglib_network_mock.go

 	"net"
 	"net/http"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 	"github.com/stretchr/testify/mock"
 )
 

internal/utils/make_qr_code_url_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/utils"
+	"github.com/dolonet/mtg-multi/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 

internal/utils/net_listener.go

 	"fmt"
 	"net"
 
-	"github.com/9seconds/mtg/v2/network"
+	"github.com/dolonet/mtg-multi/network"
 )
 
 type Listener struct {

internal/utils/read_config.go

 	"fmt"
 	"os"
 
-	"github.com/9seconds/mtg/v2/internal/config"
+	"github.com/dolonet/mtg-multi/internal/config"
 )
 
 func ReadConfig(path string) (*config.Config, error) {

internal/utils/read_config_test.go

 	"path/filepath"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/utils"
+	"github.com/dolonet/mtg-multi/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 

ipblocklist/files/http_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
 	"github.com/stretchr/testify/suite"
 )
 

ipblocklist/files/local_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

ipblocklist/files/mem_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
 	"github.com/stretchr/testify/suite"
 )
 

ipblocklist/firehol.go

 	"sync"
 	"time"
 
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/panjf2000/ants/v2"
 	"github.com/yl2chen/cidranger"
 )

ipblocklist/firehol_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/ipblocklist"
-	"github.com/9seconds/mtg/v2/logger"
-	"github.com/9seconds/mtg/v2/network"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/ipblocklist"
+	"github.com/dolonet/mtg-multi/logger"
+	"github.com/dolonet/mtg-multi/network"
 	"github.com/jarcoal/httpmock"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"

ipblocklist/noop.go

 	"net"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 )
 
 type noop struct{}

ipblocklist/noop_test.go

 	"net"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/ipblocklist"
+	"github.com/dolonet/mtg-multi/ipblocklist"
 	"github.com/stretchr/testify/suite"
 )
 

logger/noop.go

 package logger
 
-import "github.com/9seconds/mtg/v2/mtglib"
+import "github.com/dolonet/mtg-multi/mtglib"
 
 type noopLogger struct{}
 

logger/noop_test.go

 	"io"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/logger"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/logger"
 	"github.com/stretchr/testify/suite"
 )
 

logger/zerolog.go

 import (
 	"fmt"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/rs/zerolog"
 )
 

logger/zerolog_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/logger"
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/logger"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"

main.go

 package main
 
 import (
-	"github.com/9seconds/mtg/v2/internal/cli"
+	"github.com/dolonet/mtg-multi/internal/cli"
 	"github.com/alecthomas/kong"
 )
 

mtglib/conns.go

 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net"
+	"sync/atomic"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 	"github.com/pires/go-proxyproto"
 )
 
 	}
 }
 
+// idleTracker is a shared idle tracker for a pair of relay connections.
+// Both directions update the same timestamp so that activity in one direction
+// prevents the other (idle) direction from timing out.
+type idleTracker struct {
+	lastActive atomic.Pointer[time.Time]
+	timeout    time.Duration
+}
+
+func newIdleTracker(timeout time.Duration) *idleTracker {
+	t := &idleTracker{timeout: timeout}
+	t.touch()
+
+	return t
+}
+
+func (t *idleTracker) touch() {
+	stamp := time.Now()
+	t.lastActive.Store(&stamp)
+}
+
+func (t *idleTracker) isIdle() bool {
+	return time.Since(*t.lastActive.Load()) >= t.timeout
+}
+
 type connIdleTimeout struct {
 	essentials.Conn
 
-	timeout time.Duration
+	tracker *idleTracker
 }
 
 func (c connIdleTimeout) Read(b []byte) (int, error) {
-	c.SetReadDeadline(time.Now().Add(c.timeout)) //nolint: errcheck
+	var netErr net.Error
+
+	for {
+		c.SetReadDeadline(time.Now().Add(c.tracker.timeout)) //nolint: errcheck
 
-	return c.Conn.Read(b) //nolint: wrapcheck
+		n, err := c.Conn.Read(b)
+
+		switch {
+		case err == nil:
+			c.tracker.touch()
+			return n, nil
+		case errors.As(err, &netErr) && netErr.Timeout() && !c.tracker.isIdle():
+			continue
+		}
+
+		return n, err
+	}
 }
 
 func (c connIdleTimeout) Write(b []byte) (int, error) {
-	c.SetWriteDeadline(time.Now().Add(c.timeout)) //nolint: errcheck
+	c.SetWriteDeadline(time.Now().Add(c.tracker.timeout)) //nolint: errcheck
 
-	return c.Conn.Write(b) //nolint: wrapcheck
+	n, err := c.Conn.Write(b)
+	if n > 0 {
+		c.tracker.touch()
+	}
+
+	return n, err //nolint: wrapcheck
 }

mtglib/conns_internal_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/dolonet/mtg-multi/internal/testlib"
 	"github.com/pires/go-proxyproto"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )
 
+type netTimeoutError struct{}
+
+func (e netTimeoutError) Error() string   { return "i/o timeout" }
+func (e netTimeoutError) Timeout() bool   { return true }
+func (e netTimeoutError) Temporary() bool { return true }
+
 type ConnRewindBaseConn struct {
 	testlib.EssentialsConnMock
 
 	suite.targetConnMock.AssertExpectations(suite.T())
 }
 
+type IdleTrackerTestSuite struct {
+	suite.Suite
+}
+
+func (suite *IdleTrackerTestSuite) TestNewNotIdle() {
+	tracker := newIdleTracker(time.Second)
+	suite.False(tracker.isIdle())
+}
+
+func (suite *IdleTrackerTestSuite) TestIdleAfterTimeout() {
+	tracker := newIdleTracker(10 * time.Millisecond)
+	time.Sleep(20 * time.Millisecond)
+
+	suite.True(tracker.isIdle())
+}
+
+func (suite *IdleTrackerTestSuite) TestTouchResetsIdle() {
+	tracker := newIdleTracker(50 * time.Millisecond)
+	time.Sleep(30 * time.Millisecond)
+
+	tracker.touch()
+
+	suite.False(tracker.isIdle())
+}
+
+type ConnIdleTimeoutTestSuite struct {
+	suite.Suite
+
+	connMock *testlib.EssentialsConnMock
+	tracker  *idleTracker
+	conn     connIdleTimeout
+}
+
+func (suite *ConnIdleTimeoutTestSuite) SetupTest() {
+	suite.connMock = &testlib.EssentialsConnMock{}
+	suite.tracker = newIdleTracker(time.Second)
+	suite.conn = connIdleTimeout{
+		Conn:    suite.connMock,
+		tracker: suite.tracker,
+	}
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TearDownTest() {
+	suite.connMock.AssertExpectations(suite.T())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadOk() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadNonTimeoutErr() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, io.EOF)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.True(errors.Is(err, io.EOF))
+	suite.Equal(0, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadTimeoutRetriesWhenNotIdle() {
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+	suite.connMock.On("Read", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestReadTimeoutClosesWhenIdle() {
+	suite.tracker = newIdleTracker(time.Millisecond)
+	suite.conn = connIdleTimeout{
+		Conn:    suite.connMock,
+		tracker: suite.tracker,
+	}
+
+	time.Sleep(5 * time.Millisecond)
+
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.Equal(0, n)
+
+	netErr, ok := err.(net.Error) //nolint: errorlint
+	suite.True(ok)
+	suite.True(netErr.Timeout())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestSharedTrackerPreventsFalseTimeout() {
+	connMock2 := &testlib.EssentialsConnMock{}
+	conn2 := connIdleTimeout{
+		Conn:    connMock2,
+		tracker: suite.tracker,
+	}
+
+	connMock2.On("SetWriteDeadline", mock.Anything).Return(nil)
+	connMock2.On("Write", mock.Anything).Once().Return(5, nil)
+
+	_, _ = conn2.Write(make([]byte, 5))
+
+	suite.connMock.On("SetReadDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Read", mock.Anything).Once().Return(0, netTimeoutError{})
+	suite.connMock.On("Read", mock.Anything).Once().Return(3, nil)
+
+	n, err := suite.conn.Read(make([]byte, 10))
+	suite.NoError(err)
+	suite.Equal(3, n)
+
+	connMock2.AssertExpectations(suite.T())
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestWriteOk() {
+	suite.connMock.On("SetWriteDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Write", mock.Anything).Once().Return(5, nil)
+
+	n, err := suite.conn.Write(make([]byte, 5))
+	suite.NoError(err)
+	suite.Equal(5, n)
+}
+
+func (suite *ConnIdleTimeoutTestSuite) TestWriteErr() {
+	suite.connMock.On("SetWriteDeadline", mock.Anything).Return(nil)
+	suite.connMock.On("Write", mock.Anything).Once().Return(0, io.EOF)
+
+	n, err := suite.conn.Write(make([]byte, 5))
+	suite.True(errors.Is(err, io.EOF))
+	suite.Equal(0, n)
+}
+
 func TestConnTraffic(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ConnTrafficTestSuite{})
 	t.Parallel()
 	suite.Run(t, &ConnProxyProtocolTestSuite{})
 }
+
+func TestIdleTracker(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &IdleTrackerTestSuite{})
+}
+
+func TestConnIdleTimeout(t *testing.T) {
+	t.Parallel()
+	suite.Run(t, &ConnIdleTimeoutTestSuite{})
+}

mtglib/counting_conn.go

 package mtglib
 
 import (
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 // countingConn wraps essentials.Conn and counts bytes through a cached

mtglib/events_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/stretchr/testify/suite"
 )
 

mtglib/init.go

 	"net/http"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 var (

mtglib/internal/dc/addr.go

 import (
 	"fmt"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
+	"github.com/dolonet/mtg-multi/mtglib/internal/obfuscation"
 )
 
 type Addr struct {

mtglib/internal/dc/init.go

 	"net"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 type preferIP uint8

mtglib/internal/dc/view.go

 }
 
 func (d dcView) getV4(dc int) []Addr {
-	addrs := d.publicConfigs.getV4(dc)
+	var addrs []Addr
+
 	addrs = append(addrs, defaultDCAddrSet.getV4(dc)...)
+	addrs = append(addrs, d.publicConfigs.getV4(dc)...)
 
 	return addrs
 }
 
 func (d dcView) getV6(dc int) []Addr {
-	addrs := d.publicConfigs.getV6(dc)
+	var addrs []Addr
+
 	addrs = append(addrs, defaultDCAddrSet.getV6(dc)...)
+	addrs = append(addrs, d.publicConfigs.getV6(dc)...)
 
 	return addrs
 }

mtglib/internal/doppel/conn.go

 	"sync"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 var doppelBufPool = sync.Pool{

mtglib/internal/doppel/conn_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

mtglib/internal/doppel/ganger.go

 	"sync/atomic"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 const (

mtglib/internal/doppel/ganger_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/dolonet/mtg-multi/internal/testlib"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

mtglib/internal/doppel/init.go

 	"net/http"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 const (

mtglib/internal/doppel/init_test.go

 	"net/http/httptest"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

mtglib/internal/doppel/scout.go

 	"strings"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 // ScoutResult holds measurements from a single scout HTTP request.
 		client.CloseIdleConnections()
 	}
 
-	if err != nil || len(results.data) == 0 {
+	if err != nil {
 		return ScoutResult{}, err
 	}
 
+	data, writeIndex := results.Snapshot()
+
+	if len(data) == 0 {
+		return ScoutResult{}, nil
+	}
+
 	var result ScoutResult
 
 	// Compute inter-record durations (existing logic).
 	lastTimestamp := time.Time{}
 
-	for i, v := range results.data {
+	for i, v := range data {
 		if v.recordType != tls.TypeApplicationData {
 			continue
 		}
 
 		if lastTimestamp.IsZero() {
 			if i > 0 {
-				lastTimestamp = results.data[i-1].timestamp
+				lastTimestamp = data[i-1].timestamp
 			} else {
 				lastTimestamp = v.timestamp
 			}
 	// Compute cert size: sum of ApplicationData payload between CCS and
 	// the first client Write (which marks the end of server handshake).
 	seenCCS := false
-	boundary := results.writeIndex
+	boundary := writeIndex
 	if boundary < 0 {
-		boundary = len(results.data)
+		boundary = len(data)
 	}
 
-	for i, v := range results.data {
+	for i, v := range data {
 		if i >= boundary {
 			break
 		}

mtglib/internal/doppel/scout_conn.go

 	"encoding/binary"
 	"io"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 type ScoutConn struct {

mtglib/internal/doppel/scout_conn_collected.go

 package doppel
 
-import "time"
+import (
+	"slices"
+	"sync"
+	"time"
+)
 
 const (
 	ScoutConnCollectedPreallocSize = 100
 }
 
 type ScoutConnCollected struct {
+	mu         sync.Mutex
 	data       []ScoutConnResult
 	writeIndex int // index at which client first wrote post-handshake data; -1 if not set
 }
 
 func (s *ScoutConnCollected) Add(record byte, payloadLen int) {
+	s.mu.Lock()
 	s.data = append(s.data, ScoutConnResult{
 		timestamp:  time.Now(),
 		recordType: record,
 		payloadLen: payloadLen,
 	})
+	s.mu.Unlock()
 }
 
 // MarkWrite records the current data length as the handshake boundary.
 func (s *ScoutConnCollected) MarkWrite() {
+	s.mu.Lock()
 	if s.writeIndex < 0 {
 		s.writeIndex = len(s.data)
 	}
+	s.mu.Unlock()
+}
+
+// Snapshot returns a copy of the collected data and the write index.
+func (s *ScoutConnCollected) Snapshot() ([]ScoutConnResult, int) {
+	s.mu.Lock()
+	snapshot := slices.Clone(s.data)
+	writeIndex := s.writeIndex
+	s.mu.Unlock()
+
+	return snapshot, writeIndex
 }
 
 func NewScoutConnCollected() *ScoutConnCollected {

mtglib/internal/doppel/scout_conn_collected_test.go

 package doppel
 
 import (
+	"sync"
 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 	"github.com/stretchr/testify/suite"
 )
 
 	collected := NewScoutConnCollected()
 	collected.Add(tls.TypeApplicationData, 100)
 
-	suite.Len(collected.data, 1)
-	suite.Equal(byte(tls.TypeApplicationData), collected.data[0].recordType)
+	data, _ := collected.Snapshot()
+
+	suite.Len(data, 1)
+	suite.Equal(byte(tls.TypeApplicationData), data[0].recordType)
 }
 
 func (suite *ScoutConnCollectedTestSuite) TestAddTimestampsAreMonotonic() {
 	time.Sleep(time.Microsecond)
 	collected.Add(tls.TypeApplicationData, 100)
 
-	for i := 1; i < len(collected.data); i++ {
-		suite.True(collected.data[i].timestamp.After(collected.data[i-1].timestamp))
+	data, _ := collected.Snapshot()
+
+	for i := 1; i < len(data); i++ {
+		suite.True(data[i].timestamp.After(data[i-1].timestamp))
 	}
 }
 
+func (suite *ScoutConnCollectedTestSuite) TestConcurrentAddSnapshot() {
+	collected := NewScoutConnCollected()
+
+	var wg sync.WaitGroup
+
+	wg.Add(3)
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 1000; i++ {
+			collected.Add(tls.TypeApplicationData, i)
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 100; i++ {
+			collected.MarkWrite()
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+
+		for i := 0; i < 1000; i++ {
+			// call Snapshot concurrently to exercise the lock under -race
+			collected.Snapshot() //nolint:errcheck
+		}
+	}()
+
+	wg.Wait()
+
+	data, writeIndex := collected.Snapshot()
+	suite.Len(data, 1000)
+	suite.GreaterOrEqual(writeIndex, 0)
+}
+
 func TestScoutConnCollected(t *testing.T) {
 	t.Parallel()
 	suite.Run(t, &ScoutConnCollectedTestSuite{})

mtglib/internal/obfuscation/conn.go

 import (
 	"crypto/cipher"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 type conn struct {

mtglib/internal/obfuscation/conn_test.go

 	"encoding/hex"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/internal/testlib"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"

mtglib/internal/obfuscation/obfuscator.go

 	"hash"
 	"io"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 type Obfuscator struct {

mtglib/internal/obfuscation/obfuscator_fuzz_test.go

 	"bytes"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/obfuscation"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )

mtglib/internal/obfuscation/obfuscator_test.go

 	"bytes"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/obfuscation"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

mtglib/internal/relay/pool_settings_constrained.go

 
 package relay
 
-import "github.com/9seconds/mtg/v2/mtglib/internal/tls"
+import "github.com/dolonet/mtg-multi/mtglib/internal/tls"
 
 const (
 	// MIPS is quite short in resources, and usually it means that it will run

mtglib/internal/relay/pool_settings_other.go

 
 package relay
 
-import "github.com/9seconds/mtg/v2/mtglib/internal/tls"
+import "github.com/dolonet/mtg-multi/mtglib/internal/tls"
 
 const (
 	bufPoolSize = tls.MaxRecordPayloadSize

mtglib/internal/relay/relay.go

 	"errors"
 	"io"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 func Relay(ctx context.Context, log Logger, telegramConn, clientConn essentials.Conn) {

mtglib/internal/relay/relay_bench_test.go

 	"sync/atomic"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 // mockConn wraps a net.Conn to satisfy essentials.Conn.

mtglib/internal/relay/relay_test.go

 	"io"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/relay"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/relay"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

mtglib/internal/relay/stack_bench_test.go

 	"sync"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 // BenchmarkStackVsPool measures memory consumption when N goroutines hold

mtglib/internal/relay/stress_bench_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 // ============================================================

mtglib/internal/tls/conn.go

 	"bufio"
 	"bytes"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 const (

mtglib/internal/tls/conn_test.go

 	"io"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
+	"github.com/dolonet/mtg-multi/internal/testlib"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )

mtglib/internal/tls/fake/client_side.go

 	"slices"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 )
 
 const (

mtglib/internal/tls/fake/client_side_fuzz_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

mtglib/internal/tls/fake/client_side_snapshot_test.go

 	"strings"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

mtglib/internal/tls/fake/client_side_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/internal/testlib"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/dolonet/mtg-multi/internal/testlib"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"

mtglib/internal/tls/fake/server_side.go

 	"io"
 	rnd "math/rand/v2"
 
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
 	"golang.org/x/crypto/curve25519"
 )
 

mtglib/internal/tls/fake/server_side_test.go

 	"crypto/sha256"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls/fake"
 	"github.com/stretchr/testify/suite"
 )
 

mtglib/proxy.go

 	"sync"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
-	"github.com/9seconds/mtg/v2/mtglib/internal/dc"
-	"github.com/9seconds/mtg/v2/mtglib/internal/doppel"
-	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
-	"github.com/9seconds/mtg/v2/mtglib/internal/relay"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls"
-	"github.com/9seconds/mtg/v2/mtglib/internal/tls/fake"
+	"github.com/dolonet/mtg-multi/essentials"
+	"github.com/dolonet/mtg-multi/mtglib/internal/dc"
+	"github.com/dolonet/mtg-multi/mtglib/internal/doppel"
+	"github.com/dolonet/mtg-multi/mtglib/internal/obfuscation"
+	"github.com/dolonet/mtg-multi/mtglib/internal/relay"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls"
+	"github.com/dolonet/mtg-multi/mtglib/internal/tls/fake"
 	"github.com/panjf2000/ants/v2"
 )
 
 		return
 	}
 
+	tracker := newIdleTracker(p.idleTimeout)
+
 	relay.Relay(
 		ctx,
 		ctx.logger.Named("relay"),
-		connIdleTimeout{Conn: ctx.telegramConn, timeout: p.idleTimeout},
-		newCountingConn(connIdleTimeout{Conn: ctx.clientConn, timeout: p.idleTimeout}, p.stats, ctx.secretName),
+		connIdleTimeout{Conn: ctx.telegramConn, tracker: tracker},
+		newCountingConn(connIdleTimeout{Conn: ctx.clientConn, tracker: tracker}, p.stats, ctx.secretName),
 	)
 }
 
 		stream:   p.eventStream,
 	}
 
+	tracker := newIdleTracker(p.idleTimeout)
+
 	relay.Relay(
 		ctx,
 		ctx.logger.Named("domain-fronting"),
-		connIdleTimeout{Conn: frontConn, timeout: p.idleTimeout},
-		connIdleTimeout{Conn: conn, timeout: p.idleTimeout},
+		connIdleTimeout{Conn: frontConn, tracker: tracker},
+		connIdleTimeout{Conn: conn, tracker: tracker},
 	)
 }
 

mtglib/proxy_test.go

 	"testing"
 	"time"
 
-	"github.com/9seconds/mtg/v2/antireplay"
-	"github.com/9seconds/mtg/v2/events"
-	"github.com/9seconds/mtg/v2/ipblocklist"
-	"github.com/9seconds/mtg/v2/ipblocklist/files"
-	"github.com/9seconds/mtg/v2/logger"
-	"github.com/9seconds/mtg/v2/mtglib"
-	"github.com/9seconds/mtg/v2/network"
+	"github.com/dolonet/mtg-multi/antireplay"
+	"github.com/dolonet/mtg-multi/events"
+	"github.com/dolonet/mtg-multi/ipblocklist"
+	"github.com/dolonet/mtg-multi/ipblocklist/files"
+	"github.com/dolonet/mtg-multi/logger"
+	"github.com/dolonet/mtg-multi/mtglib"
+	"github.com/dolonet/mtg-multi/network"
 	"github.com/stretchr/testify/suite"
 	"github.com/yl2chen/cidranger"
 )
 	addr := fmt.Sprintf("https://%s/headers", suite.ProxyAddress())
 
 	resp, err := client.Get(addr) //nolint: noctx
-	suite.NoError(err)
+	suite.Require().NoError(err)
 
 	defer resp.Body.Close() //nolint: errcheck
 

mtglib/secret_test.go

 	"encoding/json"
 	"testing"
 
-	"github.com/9seconds/mtg/v2/mtglib"
+	"github.com/dolonet/mtg-multi/mtglib"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )

mtglib/stream_context.go

 	"net"
 	"time"
 
-	"github.com/9seconds/mtg/v2/essentials"
+	"github.com/dolonet/mtg-multi/essentials"
 )
 
 type streamContext struct {