Preserve startup error when browser dialer cleanup fails

Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b8c640ab-f93c-4609-8e34-a8e14e2be9e7 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>
Handle browser dialer cleanup errors on instance lifecycle
2026-10-02 13:56:39 +00:00 · 2026-04-27 13:38:42 +00:00 · 2026-04-27 13:36:11 +00:00 · 2026-04-27 13:32:47 +00:00 · 2026-04-27 11:55:25 +00:00 · 2026-04-27 11:52:48 +00:00
560 changed files with 13149 additions and 38173 deletions
@@ -1 +0,0 @@
-powershell.exe -ExecutionPolicy Bypass -File ".\xray_no_window.ps1"
@@ -1 +0,0 @@
-Start-Process -FilePath ".\xray.exe" -ArgumentList "-config .\config.json" -WindowStyle Hidden
@@ -1 +0,0 @@
-CreateObject("Wscript.Shell").Run "xray.exe -config config.json",0
@@ -32,13 +32,9 @@ RUN echo '{}' >/tmp/usr/local/etc/xray/03_routing.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/04_policy.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/05_inbounds.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/06_outbounds.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/07_stats.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/08_fakedns.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/09_metrics.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/10_observatory.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/11_geodata.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/12_env.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/99_version.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/07_transport.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/08_stats.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/09_reverse.json

 # Create log files
 RUN mkdir -p /tmp/var/log/xray && touch \
@@ -32,13 +32,9 @@ RUN echo '{}' >/tmp/usr/local/etc/xray/03_routing.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/04_policy.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/05_inbounds.json
 RUN echo '{}' >/tmp/usr/local/etc/xray/06_outbounds.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/07_stats.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/08_fakedns.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/09_metrics.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/10_observatory.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/11_geodata.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/12_env.json
-RUN echo '{}' >/tmp/usr/local/etc/xray/99_version.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/07_transport.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/08_stats.json
+RUN echo '{}' >/tmp/usr/local/etc/xray/09_reverse.json

 # Create log files
 RUN mkdir -p /tmp/var/log/xray && touch \
@@ -64,16 +64,8 @@ jobs:
          echo "Latest: '$LATEST'."
          echo "LATEST=$LATEST" >>${GITHUB_ENV}

-          NEWEST=false
-          if [[ "${{ github.event_name }}" == "release" ]]; then
-            NEWEST=true
-          fi
-
-          echo "Newest: '$NEWEST'."
-          echo "NEWEST=$NEWEST" >>${GITHUB_ENV}
-
      - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v4
@@ -82,7 +74,7 @@ jobs:
        uses: docker/setup-buildx-action@v4

      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v4.6.0
+        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
@@ -132,13 +124,6 @@ jobs:
            ${{ env.FULL_IMAGE_NAME }}:${{ env.IMAGE_TAG }}
          fi

-          if [[ "${{ env.NEWEST }}" == "true" ]]; then
-            echo "Adding 'pre-release' tag to manifest: '${{ env.FULL_IMAGE_NAME }}:pre-release'."
-            docker buildx imagetools create \
-            --tag ${{ env.FULL_IMAGE_NAME }}:pre-release \
-            ${{ env.FULL_IMAGE_NAME }}:${{ env.IMAGE_TAG }}
-          fi
-
      - name: Inspect image
        run: |
          docker buildx imagetools inspect ${{ env.FULL_IMAGE_NAME }}:${{ env.IMAGE_TAG }}
@@ -146,7 +131,3 @@ jobs:
          if [[ "${{ env.LATEST }}" == "true" ]]; then
            docker buildx imagetools inspect ${{ env.FULL_IMAGE_NAME }}:latest
          fi
-
-          if [[ "${{ env.NEWEST }}" == "true" ]]; then
-            docker buildx imagetools inspect ${{ env.FULL_IMAGE_NAME }}:pre-release
-          fi
@@ -11,16 +11,15 @@ on:
 jobs:
  check-assets:
    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    steps:
      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-

      - name: Restore Wintun Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-wintun-
@@ -76,14 +75,13 @@ jobs:
      fail-fast: false

    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    env:
      GOOS: ${{ matrix.goos}}
      GOARCH: ${{ matrix.goarch }}
      CGO_ENABLED: 0
    steps:
      - name: Checkout codebase
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Show workflow information
        run: |
@@ -92,7 +90,7 @@ jobs:
          echo "ASSET_NAME=$_NAME" >> $GITHUB_ENV

      - name: Set up Go
-        uses: actions/setup-go@v7
+        uses: actions/setup-go@v6
        with:
          go-version-file: go.mod
          check-latest: true
@@ -119,13 +117,13 @@ jobs:
          # go build -o build_assets/wxray.exe -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-H windowsgui -X github.com/xtls/xray-core/core.build=${COMMID} -s -w -buildid=" -v ./main

      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-

      - name: Restore Wintun Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-wintun-
@@ -134,17 +132,15 @@ jobs:
        run: |
          mv -f resources/geo* build_assets/
          if [[ ${GOOS} == 'windows' ]]; then
-            cp .github/build/windows/* build_assets/
-          fi
-          if [[ ${GOOS} == 'windows' ]]; then
-            echo 'Adding Wintun into packages'
+            echo 'CreateObject("Wscript.Shell").Run "xray.exe -config config.json",0' > build_assets/xray_no_window.vbs
+            echo 'Start-Process -FilePath ".\xray.exe" -ArgumentList "-config .\config.json" -WindowStyle Hidden' > build_assets/xray_no_window.ps1
            if [[ ${GOARCH} == 'amd64' ]]; then
              mv resources/wintun/bin/amd64/wintun.dll build_assets/
            fi
            if [[ ${GOARCH} == '386' ]]; then
              mv resources/wintun/bin/x86/wintun.dll build_assets/
            fi
-            mv resources/wintun/LICENSE.txt build_assets/LICENSE-Wintun
+            mv resources/wintun/LICENSE.txt build_assets/LICENSE-wintun.txt
          fi

      - name: Copy README.md & LICENSE
@@ -11,16 +11,15 @@ on:
 jobs:
  check-assets:
    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    steps:
      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-

      - name: Restore Wintun Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-wintun-
@@ -162,7 +161,6 @@ jobs:
      fail-fast: false

    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    env:
      GOOS: ${{ matrix.goos }}
      GOARCH: ${{ matrix.goarch }}
@@ -170,7 +168,7 @@ jobs:
      CGO_ENABLED: 0
    steps:
      - name: Checkout codebase
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6

      - name: Set up NDK
        if: matrix.goos == 'android'
@@ -193,7 +191,7 @@ jobs:
          echo "ASSET_NAME=$_NAME" >> $GITHUB_ENV

      - name: Set up Go
-        uses: actions/setup-go@v7
+        uses: actions/setup-go@v6
        with:
          go-version-file: go.mod
          check-latest: true
@@ -210,9 +208,6 @@ jobs:
            go build -o build_assets/xray.exe -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=${COMMID} -s -w -buildid=" -v ./main
            # The line below is for without running conhost.exe version. Commented for not being used. Provided for reference.
            # go build -o build_assets/wxray.exe -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-H windowsgui -X github.com/xtls/xray-core/core.build=${COMMID} -s -w -buildid=" -v ./main
-          elif [[ ${GOOS} == 'android' ]]; then
-            echo 'Building Xray for Android...'
-            go build -o build_assets/xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=${COMMID} -s -w -buildid= -checklinkname=0" -v ./main
          else
            echo 'Building Xray...'
            if [[ ${GOARCH} == 'mips' || ${GOARCH} == 'mipsle' ]]; then
@@ -225,14 +220,14 @@ jobs:
          fi

      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-

      - name: Restore Wintun Cache
        if: matrix.goos == 'windows'
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-wintun-
@@ -241,10 +236,8 @@ jobs:
        run: |
          mv -f resources/geo* build_assets/
          if [[ ${GOOS} == 'windows' ]]; then
-            cp .github/build/windows/* build_assets/
-          fi
-          if [[ ${GOOS} == 'windows' ]]; then
-            echo 'Adding Wintun into packages'
+            echo 'CreateObject("Wscript.Shell").Run "xray.exe -config config.json",0' > build_assets/xray_no_window.vbs
+            echo 'Start-Process -FilePath ".\xray.exe" -ArgumentList "-config .\config.json" -WindowStyle Hidden' > build_assets/xray_no_window.ps1
            if [[ ${GOARCH} == 'amd64' ]]; then
              mv resources/wintun/bin/amd64/wintun.dll build_assets/
            fi
@@ -254,7 +247,7 @@ jobs:
            if [[ ${GOARCH} == 'arm64' ]]; then
              mv resources/wintun/bin/arm64/wintun.dll build_assets/
            fi
-            mv resources/wintun/LICENSE.txt build_assets/LICENSE-Wintun
+            mv resources/wintun/LICENSE.txt build_assets/LICENSE-wintun.txt
          fi

      - name: Copy README.md & LICENSE
@@ -26,7 +26,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-
@@ -59,7 +59,7 @@ jobs:
            done

      - name: Save Geodat Cache
-        uses: actions/cache/save@v6
+        uses: actions/cache/save@v5
        if: ${{ steps.update.outputs.unhit }}
        with:
          path: resources
@@ -68,12 +68,9 @@ jobs:
  wintun:
    if: github.event.schedule == '30 22 * * *' || github.event_name == 'push' || github.event_name == 'pull_request' || github.event_name == 'workflow_dispatch'
    runs-on: ubuntu-latest
-    env:
-      ASSETVER: 0.14.1
-      ASSETHASH: 07c256185d6ee3652e09fa55c0b673e2624b565e02c4b9091c79ca7d2f24ef51
    steps:
      - name: Restore Wintun Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-wintun-
@@ -99,6 +96,7 @@ jobs:
              echo -e "Checking if wintun.dll for ${ARCHITECTURE} exists..."
              if [ -s "./resources/wintun/bin/${ARCHITECTURE}/wintun.dll" ]; then
                  echo -e "wintun.dll for ${ARCHITECTURE} exists"
+                  continue
              else
                  echo -e "wintun.dll for ${ARCHITECTURE} is missing"
                  missing=true
@@ -115,21 +113,16 @@ jobs:
            fi
            if [[ "$missing" == true ]]; then
              FILENAME=wintun.zip
-              DOWNLOAD_FILE=wintun-${ASSETVER}.zip
+              DOWNLOAD_FILE=wintun-0.14.1.zip
              echo -e "Downloading https://www.wintun.net/builds/${DOWNLOAD_FILE}..."
              curl -L "https://www.wintun.net/builds/${DOWNLOAD_FILE}" -o "${FILENAME}"
-              if [[ "$(sha256sum "./${FILENAME}" | awk -F ' ' '{print $1}')" == "${ASSETHASH}" ]]; then
-                echo -e "Unpacking wintun..."
-                unzip -u ${FILENAME} -d resources/
-                echo "unhit=true" >> $GITHUB_OUTPUT
-              else
-                echo -e "Digest of ${FILENAME} mismatch."
-                exit 1
-              fi
+              echo -e "Unpacking wintun..."
+              unzip -u ${FILENAME} -d resources/
+              echo "unhit=true" >> $GITHUB_OUTPUT
            fi

      - name: Save Wintun Cache
-        uses: actions/cache/save@v6
+        uses: actions/cache/save@v5
        if: ${{ steps.update.outputs.unhit }}
        with:
          path: resources
@@ -1,4 +1,4 @@
-name: Tests and Checkings
+name: Test

 on:
  push:
@@ -8,10 +8,9 @@ on:
 jobs:
  check-assets:
    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    steps:
      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-
@@ -37,10 +36,9 @@ jobs:

  check-proto:
    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    steps:
      - name: Checkout codebase
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
      - name: Check Proto Version Header
        run: |
          head -n 4 core/config.pb.go > ref.txt
@@ -52,26 +50,8 @@ jobs:
            fi
          done

-  check-format:
-    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout codebase
-        uses: actions/checkout@v7
-      - name: Set up Go
-        uses: actions/setup-go@v7
-        with:
-          go-version-file: go.mod
-          check-latest: true
-          cache: false
-      - name: Check Format
-        run: go run ./infra/vformat/main.go -mode check -pwd ./
-
  test:
    needs: check-assets
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
    permissions:
      contents: read
    runs-on: ${{ matrix.os }}
@@ -81,14 +61,14 @@ jobs:
        os: [windows-latest, ubuntu-latest, macos-latest]
    steps:
      - name: Checkout codebase
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
      - name: Set up Go
-        uses: actions/setup-go@v7
+        uses: actions/setup-go@v6
        with:
          go-version-file: go.mod
          check-latest: true
      - name: Restore Geodat Cache
-        uses: actions/cache/restore@v6
+        uses: actions/cache/restore@v5
        with:
          path: resources
          key: xray-geodat-
@@ -73,7 +73,8 @@
  - [Xray_bash_onekey](https://github.com/hello-yunshu/Xray_bash_onekey), [XTool](https://github.com/LordPenguin666/XTool), [VPainLess](https://github.com/vpainless/vpainless)
  - [v2ray-agent](https://github.com/mack-a/v2ray-agent), [Xray_onekey](https://github.com/wulabing/Xray_onekey), [ProxySU](https://github.com/proxysu/ProxySU)
 - Magisk
-  - [Magic_V2Ray](https://github.com/vincentng295/Magic_V2Ray)
+  - [NetProxy-Magisk](https://github.com/Fanju6/NetProxy-Magisk)
+  - [Xray4Magisk](https://github.com/Asterisk4Magisk/Xray4Magisk)
  - [Xray_For_Magisk](https://github.com/E7KMbb/Xray_For_Magisk)
 - Homebrew
  - `brew install xray`
@@ -110,8 +111,6 @@
  - [Invisible Man - Xray](https://github.com/InvisibleManVPN/InvisibleMan-XRayClient)
  - [AnyPortal](https://github.com/AnyPortal/AnyPortal)
  - [GenyConnect](https://github.com/genyleap/GenyConnect)
-  - [OneXray](https://github.com/OneXray/OneXray)
-  - [XrayUI-dev](https://github.com/PhoenixNil/XrayUI-dev)
 - Android
  - [v2rayNG](https://github.com/2dust/v2rayNG)
  - [X-flutter](https://github.com/XTLS/X-flutter)
@@ -119,8 +118,7 @@
  - [SimpleXray](https://github.com/lhear/SimpleXray)
  - [XrayFA](https://github.com/Q7DF1/XrayFA)
  - [AnyPortal](https://github.com/AnyPortal/AnyPortal)
-  - [OneXray](https://github.com/OneXray/OneXray)
-  - [AsteriskNG](https://github.com/Asterisk4Magisk/AsteriskNG)
+  - [NetProxy-Magisk](https://github.com/Fanju6/NetProxy-Magisk)
 - iOS & macOS arm64 & tvOS
  - [Happ](https://apps.apple.com/app/happ-proxy-utility/id6504287215) | [Happ RU](https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973) | [Happ tvOS](https://apps.apple.com/us/app/happ-proxy-utility-for-tv/id6748297274)
  - [Streisand](https://apps.apple.com/app/streisand/id6450534064)
@@ -145,14 +143,10 @@
  - [AnyPortal](https://github.com/AnyPortal/AnyPortal)
  - [v2rayN](https://github.com/2dust/v2rayN)
  - [GenyConnect](https://github.com/genyleap/GenyConnect)
-  - [OneXray](https://github.com/OneXray/OneXray)
- HarmonyOS
-  - [Hey](https://github.com/popsiclelmlm/Hey)

 ## Others that support VLESS, XTLS, REALITY, XUDP, PLUX...

 - iOS & macOS arm64 & tvOS
-  - [Anywhere](https://github.com/NodePassProject/Anywhere)
  - [Shadowrocket](https://apps.apple.com/app/shadowrocket/id932747118)
  - [Loon](https://apps.apple.com/us/app/loon/id1373567447)
  - [Egern](https://apps.apple.com/us/app/egern/id1616105820)
@@ -165,7 +159,6 @@
  - [xtls-sdk](https://github.com/remnawave/xtls-sdk)
  - [xtlsapi](https://github.com/hiddify/xtlsapi)
  - [AndroidLibXrayLite](https://github.com/2dust/AndroidLibXrayLite)
-  - [flutter_vless](https://github.com/XIIIFOX/flutter_vless)
  - [Xray-core-python](https://github.com/LorenEteval/Xray-core-python)
  - [xray-api](https://github.com/XVGuardian/xray-api)
 - [XrayR](https://github.com/XrayR-project/XrayR)
@@ -187,27 +180,6 @@
 - [Xray-core v1.0.0](https://github.com/XTLS/Xray-core/releases/tag/v1.0.0) was forked from [v2fly-core 9a03cc5](https://github.com/v2fly/v2ray-core/commit/9a03cc5c98d04cc28320fcee26dbc236b3291256), and we have made & accumulated a huge number of enhancements over time, check [the release notes for each version](https://github.com/XTLS/Xray-core/releases).
 - For third-party projects used in [Xray-core](https://github.com/XTLS/Xray-core), check your local or [the latest go.mod](https://github.com/XTLS/Xray-core/blob/main/go.mod).

-### Bundled Third-Party Components Redistribution
-
-**Certain optional features dynamically load third-party components. These optional components are separate works distributed under their own licenses, and are bundled into the ZIP package for ease of use. Users may replace these components under the licenses from these components.**
-
-These components include:
-
-#### Wintun
-
-This distribution contains unmodified official precompiled and pre-signed Wintun binaries.
-
- Project: Wintun
- Copyright: Copyright (C) 2018-2021 WireGuard LLC. All Rights Reserved.
- Redistribution License: Prebuilt Binaries License (PBL) bundled with official precompiled and pre-signed binaries from wintun.net
- Component(s): wintun.dll
- Source: https://www.wintun.net/
- Included in:
-  - Windows x86 (windows-32, win7-32)
-  - Windows x86-64 (windows-64, win7-64)
-  - Windows AArch64 (windows-arm64)
- Notes: Wintun is an optional runtime-loaded component only used for TUN inbound functionality on supported Windows platforms.
-
 ## One-line Compilation

 ### Windows (PowerShell)
@@ -231,13 +203,6 @@ Make sure that you are using the same Go version, and remember to set the git co
 CGO_ENABLED=0 go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid=" -v ./main
 ```

-For Android:
-
-```bash
-GOOS=android GOARCH=arm64 CGO_ENABLED=1 CC=/path/to/aarch64-linux-android24-clang go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid= -checklinkname=0" -v ./main
-GOOS=android GOARCH=amd64 CGO_ENABLED=1 CC=/path/to/x86_64-linux-android24-clang go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid= -checklinkname=0" -v ./main
-```
-
 If you are compiling a 32-bit MIPS/MIPSLE target, use this command instead:

 ```bash
@@ -3,7 +3,6 @@ package commander
 import (
 	"context"
 	"net"
-	"strings"
 	"sync"

 	"github.com/xtls/xray-core/common"
@@ -11,7 +10,6 @@ import (
 	"github.com/xtls/xray-core/common/signal/done"
 	core "github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/outbound"
-	"github.com/xtls/xray-core/transport/internet"
 	"google.golang.org/grpc"
 )

@@ -69,32 +67,20 @@ func (c *Commander) Start() error {
 	}
 	c.Unlock()

-	listen := func(listener net.Listener) {
+	var listen = func(listener net.Listener) {
 		if err := c.server.Serve(listener); err != nil {
 			errors.LogErrorInner(context.Background(), err, "failed to start grpc server")
 		}
 	}

 	if len(c.listen) > 0 {
-		var addr net.Addr
-
-		if strings.HasPrefix(c.listen, "/") || strings.HasPrefix(c.listen, "@") {
-			addr = &net.UnixAddr{Name: c.listen, Net: "unix"}
-		} else {
-			tcpAddr, err := net.ResolveTCPAddr("tcp", c.listen)
-			if err != nil {
-				errors.LogErrorInner(context.Background(), err, "API server failed to parse listen address ", c.listen)
-				return err
-			}
-			addr = tcpAddr
-		}
-		l, err := internet.ListenSystem(context.Background(), addr, nil)
-		if err != nil {
+		if l, err := net.Listen("tcp", c.listen); err != nil {
 			errors.LogErrorInner(context.Background(), err, "API server failed to listen on ", c.listen)
 			return err
+		} else {
+			errors.LogInfo(context.Background(), "API server listening on ", l.Addr())
+			go listen(l)
 		}
-		errors.LogInfo(context.Background(), "API server listening on ", l.Addr())
-		go listen(l)
 		return nil
 	}

@@ -162,7 +162,7 @@ func (d *DefaultDispatcher) getLink(ctx context.Context) (*transport.Link, *tran
 		p := d.policy.ForLevel(user.Level)
 		if p.Stats.UserUplink {
 			name := "user>>>" + user.Email + ">>>traffic>>>uplink"
-			if c, _ := d.stats.GetOrRegisterCounter(name); c != nil {
+			if c, _ := stats.GetOrRegisterCounter(d.stats, name); c != nil {
 				inboundLink.Writer = &SizeStatWriter{
 					Counter: c,
 					Writer:  inboundLink.Writer,
@@ -171,7 +171,7 @@ func (d *DefaultDispatcher) getLink(ctx context.Context) (*transport.Link, *tran
 		}
 		if p.Stats.UserDownlink {
 			name := "user>>>" + user.Email + ">>>traffic>>>downlink"
-			if c, _ := d.stats.GetOrRegisterCounter(name); c != nil {
+			if c, _ := stats.GetOrRegisterCounter(d.stats, name); c != nil {
 				outboundLink.Writer = &SizeStatWriter{
 					Counter: c,
 					Writer:  outboundLink.Writer,
@@ -200,13 +200,13 @@ func WrapLink(ctx context.Context, policyManager policy.Manager, statsManager st
 		p := policyManager.ForLevel(user.Level)
 		if p.Stats.UserUplink {
 			name := "user>>>" + user.Email + ">>>traffic>>>uplink"
-			if c, _ := statsManager.GetOrRegisterCounter(name); c != nil {
+			if c, _ := stats.GetOrRegisterCounter(statsManager, name); c != nil {
 				link.Reader.(*buf.TimeoutWrapperReader).Counter = c
 			}
 		}
 		if p.Stats.UserDownlink {
 			name := "user>>>" + user.Email + ">>>traffic>>>downlink"
-			if c, _ := statsManager.GetOrRegisterCounter(name); c != nil {
+			if c, _ := stats.GetOrRegisterCounter(statsManager, name); c != nil {
 				link.Writer = &SizeStatWriter{
 					Counter: c,
 					Writer:  link.Writer,
@@ -223,7 +223,7 @@ func WrapLink(ctx context.Context, policyManager policy.Manager, statsManager st

 func trackOnlineIP(ctx context.Context, sm stats.Manager, email, ip string) {
 	name := "user>>>" + email + ">>>online"
-	if om, _ := sm.GetOrRegisterOnlineMap(name); om != nil {
+	if om, _ := stats.GetOrRegisterOnlineMap(sm, name); om != nil {
 		om.AddIP(ip)
 		context.AfterFunc(ctx, func() { om.RemoveIP(ip) })
 	}
@@ -470,9 +470,6 @@ func (d *DefaultDispatcher) routedDispatch(ctx context.Context, link *transport.
 				return // DO NOT CHANGE: the traffic shouldn't be processed by default outbound if the specified outbound tag doesn't exist (yet), e.g., VLESS Reverse Proxy
 			}
 		} else {
-			if err != common.ErrNoClue {
-				errors.LogErrorInner(ctx, err, "failed to pick route for ", destination)
-			}
 			errors.LogInfo(ctx, "default route for ", destination)
 		}
 	}
@@ -139,8 +139,7 @@ func (c *CacheController) writeAndShrink(expiredKeys []string) {

 	if lenAfter == 0 {
 		if c.highWatermark >= minSizeForEmptyRebuild {
-			errors.LogDebug(
-				context.Background(), c.name,
+			errors.LogDebug(context.Background(), c.name,
 				" rebuilding empty cache map to reclaim memory.",
 				" size_before_cleanup=", lenBefore,
 				" peak_size_before_rebuild=", c.highWatermark,
@@ -154,8 +153,7 @@ func (c *CacheController) writeAndShrink(expiredKeys []string) {

 	if reductionFromPeak := c.highWatermark - lenAfter; reductionFromPeak > shrinkAbsoluteThreshold &&
 		float64(reductionFromPeak) > float64(c.highWatermark)*shrinkRatioThreshold {
-		errors.LogDebug(
-			context.Background(), c.name,
+		errors.LogDebug(context.Background(), c.name,
 			" shrinking cache map to reclaim memory.",
 			" new_size=", lenAfter,
 			" peak_size_before_shrink=", c.highWatermark,
@@ -167,6 +165,7 @@ func (c *CacheController) writeAndShrink(expiredKeys []string) {
 		c.highWatermark = lenAfter
 		go c.migrate()
 	}
+
 }

 type migrationEntry struct {
@@ -93,7 +93,6 @@ type NameServer struct {
 	UnexpectedIp    []*geodata.IPRule      `protobuf:"bytes,13,rep,name=unexpected_ip,json=unexpectedIp,proto3" json:"unexpected_ip,omitempty"`
 	ActUnprior      bool                   `protobuf:"varint,14,opt,name=actUnprior,proto3" json:"actUnprior,omitempty"`
 	PolicyID        uint32                 `protobuf:"varint,17,opt,name=policyID,proto3" json:"policyID,omitempty"`
-	Id              string                 `protobuf:"bytes,18,opt,name=id,proto3" json:"id,omitempty"`
 	unknownFields   protoimpl.UnknownFields
 	sizeCache       protoimpl.SizeCache
 }
@@ -240,13 +239,6 @@ func (x *NameServer) GetPolicyID() uint32 {
 	return 0
 }

-func (x *NameServer) GetId() string {
-	if x != nil {
-		return x.Id
-	}
-	return ""
-}
-
 type Config struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// NameServer list used by this DNS client.
@@ -266,10 +258,8 @@ type Config struct {
 	DisableFallback        bool          `protobuf:"varint,10,opt,name=disableFallback,proto3" json:"disableFallback,omitempty"`
 	DisableFallbackIfMatch bool          `protobuf:"varint,11,opt,name=disableFallbackIfMatch,proto3" json:"disableFallbackIfMatch,omitempty"`
 	EnableParallelQuery    bool          `protobuf:"varint,14,opt,name=enableParallelQuery,proto3" json:"enableParallelQuery,omitempty"`
-	// Absolute path to the Lua DNS query script.
-	Script        string `protobuf:"bytes,15,opt,name=script,proto3" json:"script,omitempty"`
-	unknownFields protoimpl.UnknownFields
-	sizeCache     protoimpl.SizeCache
+	unknownFields          protoimpl.UnknownFields
+	sizeCache              protoimpl.SizeCache
 }

 func (x *Config) Reset() {
@@ -379,13 +369,6 @@ func (x *Config) GetEnableParallelQuery() bool {
 	return false
 }

-func (x *Config) GetScript() string {
-	if x != nil {
-		return x.Script
-	}
-	return ""
-}
-
 type Config_HostMapping struct {
 	state  protoimpl.MessageState `protogen:"open.v1"`
 	Domain *geodata.DomainRule    `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
@@ -452,7 +435,7 @@ var File_app_dns_config_proto protoreflect.FileDescriptor

 const file_app_dns_config_proto_rawDesc = "" +
 	"\n" +
-	"\x14app/dns/config.proto\x12\fxray.app.dns\x1a\x1ccommon/net/destination.proto\x1a\x1bcommon/geodata/geodat.proto\"\xee\x05\n" +
+	"\x14app/dns/config.proto\x12\fxray.app.dns\x1a\x1ccommon/net/destination.proto\x1a\x1bcommon/geodata/geodat.proto\"\xde\x05\n" +
 	"\n" +
 	"NameServer\x123\n" +
 	"\aaddress\x18\x01 \x01(\v2\x19.xray.common.net.EndpointR\aaddress\x12\x1b\n" +
@@ -478,11 +461,10 @@ const file_app_dns_config_proto_rawDesc = "" +
 	"\n" +
 	"actUnprior\x18\x0e \x01(\bR\n" +
 	"actUnprior\x12\x1a\n" +
-	"\bpolicyID\x18\x11 \x01(\rR\bpolicyID\x12\x0e\n" +
-	"\x02id\x18\x12 \x01(\tR\x02idB\x0f\n" +
+	"\bpolicyID\x18\x11 \x01(\rR\bpolicyIDB\x0f\n" +
 	"\r_disableCacheB\r\n" +
 	"\v_serveStaleB\x12\n" +
-	"\x10_serveExpiredTTLJ\x04\b\x04\x10\x05\"\x9a\x05\n" +
+	"\x10_serveExpiredTTLJ\x04\b\x04\x10\x05\"\x82\x05\n" +
 	"\x06Config\x129\n" +
 	"\vname_server\x18\x05 \x03(\v2\x18.xray.app.dns.NameServerR\n" +
 	"nameServer\x12\x1b\n" +
@@ -498,8 +480,7 @@ const file_app_dns_config_proto_rawDesc = "" +
 	"\x0fdisableFallback\x18\n" +
 	" \x01(\bR\x0fdisableFallback\x126\n" +
 	"\x16disableFallbackIfMatch\x18\v \x01(\bR\x16disableFallbackIfMatch\x120\n" +
-	"\x13enableParallelQuery\x18\x0e \x01(\bR\x13enableParallelQuery\x12\x16\n" +
-	"\x06script\x18\x0f \x01(\tR\x06script\x1a}\n" +
+	"\x13enableParallelQuery\x18\x0e \x01(\bR\x13enableParallelQuery\x1a}\n" +
 	"\vHostMapping\x127\n" +
 	"\x06domain\x18\x02 \x01(\v2\x1f.xray.common.geodata.DomainRuleR\x06domain\x12\x0e\n" +
 	"\x02ip\x18\x03 \x03(\fR\x02ip\x12%\n" +
@@ -27,7 +27,6 @@ message NameServer {
  repeated xray.common.geodata.IPRule unexpected_ip = 13;
  bool actUnprior = 14;
  uint32 policyID = 17;
-  string id = 18;
 }

 enum QueryStrategy {
@@ -74,7 +73,4 @@ message Config {
  bool disableFallbackIfMatch = 11;

  bool enableParallelQuery = 14;
-
-  // Absolute path to the Lua DNS query script.
-  string script = 15;
 }
@@ -5,16 +5,18 @@ import (
 	"context"
 	go_errors "errors"
 	"fmt"
+	"os"
+	"runtime"
 	"sort"
 	"strings"
 	"sync"
+	"time"

 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/geodata"
 	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/session"
-	"github.com/xtls/xray-core/common/utils"
 	"github.com/xtls/xray-core/features/dns"
 )

@@ -31,8 +33,6 @@ type DNS struct {
 	domainMatcher          geodata.DomainMatcher
 	matcherInfos           []*DomainMatcherInfo
 	checkSystem            bool
-	script                 *scriptEngine
-	scriptPath             string
 }

 // DomainMatcherInfo contains information attached to index returned by Server.domainMatcher.
@@ -88,7 +88,7 @@ func New(ctx context.Context, config *Config) (*DNS, error) {
 		return nil, errors.New("failed to create hosts").Base(err)
 	}

-	defaultTag := config.Tag
+	var defaultTag = config.Tag
 	if len(config.Tag) == 0 {
 		defaultTag = generateRandomTag()
 	}
@@ -141,7 +141,7 @@ func New(ctx context.Context, config *Config) (*DNS, error) {
 			serveExpiredTTL = *ns.ServeExpiredTTL
 		}

-		tag := defaultTag
+		var tag = defaultTag
 		if len(ns.Tag) > 0 {
 			tag = ns.Tag
 		}
@@ -182,7 +182,6 @@ func New(ctx context.Context, config *Config) (*DNS, error) {
 		disableFallbackIfMatch: config.DisableFallbackIfMatch,
 		enableParallelQuery:    config.EnableParallelQuery,
 		checkSystem:            checkSystem,
-		scriptPath:             config.Script,
 	}, nil
 }

@@ -193,21 +192,11 @@ func (*DNS) Type() interface{} {

 // Start implements common.Runnable.
 func (s *DNS) Start() error {
-	if s.scriptPath != "" {
-		engine, err := newScriptEngine(s.scriptPath, s)
-		if err != nil {
-			return errors.New("failed to initialize DNS script").Base(err)
-		}
-		s.script = engine
-	}
 	return nil
 }

 // Close implements common.Closable.
 func (s *DNS) Close() error {
-	if s.script != nil {
-		s.script.close()
-	}
 	return nil
 }

@@ -234,7 +223,7 @@ func (s *DNS) LookupIP(domain string, option dns.IPOption) ([]net.IP, uint32, er
 	}

 	if s.checkSystem {
-		supportIPv4, supportIPv6 := utils.CheckRoutes()
+		supportIPv4, supportIPv6 := checkRoutes()
 		option.IPv4Enable = option.IPv4Enable && supportIPv4
 		option.IPv6Enable = option.IPv6Enable && supportIPv6
 	} else {
@@ -270,9 +259,6 @@ func (s *DNS) LookupIP(domain string, option dns.IPOption) ([]net.IP, uint32, er
 	}

 	// Name servers lookup
-	if s.script != nil {
-		return s.script.query(domain, option)
-	}
 	if s.enableParallelQuery {
 		return s.parallelQuery(domain, option)
 	} else {
@@ -553,3 +539,67 @@ func init() {
 		return New(ctx, config.(*Config))
 	}))
 }
+
+func probeRoutes() (ipv4 bool, ipv6 bool) {
+	if conn, err := net.Dial("udp4", "192.33.4.12:53"); err == nil {
+		ipv4 = true
+		conn.Close()
+	}
+	if conn, err := net.Dial("udp6", "[2001:500:2::c]:53"); err == nil {
+		ipv6 = true
+		conn.Close()
+	}
+	return
+}
+
+var routeCache struct {
+	sync.Once
+	sync.RWMutex
+	expire     time.Time
+	ipv4, ipv6 bool
+}
+
+func checkRoutes() (bool, bool) {
+	if !isGUIPlatform {
+		routeCache.Once.Do(func() {
+			routeCache.ipv4, routeCache.ipv6 = probeRoutes()
+		})
+		return routeCache.ipv4, routeCache.ipv6
+	}
+
+	routeCache.RWMutex.RLock()
+	now := time.Now()
+	if routeCache.expire.After(now) {
+		routeCache.RWMutex.RUnlock()
+		return routeCache.ipv4, routeCache.ipv6
+	}
+	routeCache.RWMutex.RUnlock()
+
+	routeCache.RWMutex.Lock()
+	defer routeCache.RWMutex.Unlock()
+
+	now = time.Now()
+	if routeCache.expire.After(now) { // double-check
+		return routeCache.ipv4, routeCache.ipv6
+	}
+	routeCache.ipv4, routeCache.ipv6 = probeRoutes()    // ~2ms
+	routeCache.expire = now.Add(100 * time.Millisecond) // ttl
+	return routeCache.ipv4, routeCache.ipv6
+}
+
+var isGUIPlatform = detectGUIPlatform()
+
+func detectGUIPlatform() bool {
+	switch runtime.GOOS {
+	case "android", "ios", "windows", "darwin":
+		return true
+	case "linux", "freebsd", "openbsd":
+		if t := os.Getenv("XDG_SESSION_TYPE"); t == "wayland" || t == "x11" {
+			return true
+		}
+		if os.Getenv("DISPLAY") != "" || os.Getenv("WAYLAND_DISPLAY") != "" {
+			return true
+		}
+	}
+	return false
+}
@@ -148,7 +148,7 @@ func TestUDPServerSubnet(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -210,7 +210,7 @@ func TestUDPServer(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -350,7 +350,7 @@ func TestPrioritizedDomain(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -421,7 +421,7 @@ func TestUDPServerIPv6(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -490,7 +490,7 @@ func TestStaticHostDomain(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -577,7 +577,7 @@ func TestIPMatch(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -696,7 +696,7 @@ func TestLocalDomain(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -953,7 +953,7 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) {
 		Outbound: []*core.OutboundHandlerConfig{
 			{
 				ProxySettings: serial.ToTypedMessage(&freedom.Config{
-					FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
+					IpsBlocked: &freedom.IPRules{},
 				}),
 			},
 		},
@@ -127,20 +127,15 @@ func genEDNS0Options(clientIP net.IP, padding int) *dnsmessage.Resource {
 	return opt
 }

-func buildReqMsgs(domain string, option dns_feature.IPOption, reqIDGen func() uint16, reqOpts *dnsmessage.Resource) ([]*dnsRequest, error) {
-	name, err := dnsmessage.NewName(domain)
-	if err != nil {
-		return nil, err
-	}
-
+func buildReqMsgs(domain string, option dns_feature.IPOption, reqIDGen func() uint16, reqOpts *dnsmessage.Resource) []*dnsRequest {
 	qA := dnsmessage.Question{
-		Name:  name,
+		Name:  dnsmessage.MustNewName(domain),
 		Type:  dnsmessage.TypeA,
 		Class: dnsmessage.ClassINET,
 	}

 	qAAAA := dnsmessage.Question{
-		Name:  name,
+		Name:  dnsmessage.MustNewName(domain),
 		Type:  dnsmessage.TypeAAAA,
 		Class: dnsmessage.ClassINET,
 	}
@@ -180,7 +175,7 @@ func buildReqMsgs(domain string, option dns_feature.IPOption, reqIDGen func() ui
 		})
 	}

-	return reqs, nil
+	return reqs
 }

 // parseResponse parses DNS answers from the returned payload
@@ -198,14 +193,9 @@ func parseResponse(payload []byte) (*IPRecord, error) {
 	ipRecord := &IPRecord{
 		ReqID:     h.ID,
 		RCode:     h.RCode,
+		Expire:    now.Add(time.Second * dns_feature.DefaultTTL),
 		RawHeader: &h,
 	}
-	defer func() {
-		// set to default TTL if no valid TTL is found
-		if ipRecord.Expire.IsZero() {
-			ipRecord.Expire = now.Add(time.Second * dns_feature.DefaultTTL)
-		}
-	}()

 L:
 	for {
@@ -222,7 +212,7 @@ L:
 			ttl = 1
 		}
 		expire := now.Add(time.Duration(ttl) * time.Second)
-		if ipRecord.Expire.IsZero() || ipRecord.Expire.After(expire) {
+		if ipRecord.Expire.After(expire) {
 			ipRecord.Expire = expire
 		}

@@ -2,7 +2,6 @@ package dns

 import (
 	"math/rand"
-	"strings"
 	"testing"
 	"time"

@@ -25,8 +24,7 @@ func Test_parseResponse(t *testing.T) {

 	ans = new(dns.Msg)
 	ans.Id = 1
-	ans.Answer = append(
-		ans.Answer,
+	ans.Answer = append(ans.Answer,
 		common.Must2(dns.NewRR("google.com. IN CNAME m.test.google.com")),
 		common.Must2(dns.NewRR("google.com. IN CNAME fake.google.com")),
 		common.Must2(dns.NewRR("google.com. IN A 8.8.8.8")),
@@ -36,8 +34,7 @@ func Test_parseResponse(t *testing.T) {

 	ans = new(dns.Msg)
 	ans.Id = 2
-	ans.Answer = append(
-		ans.Answer,
+	ans.Answer = append(ans.Answer,
 		common.Must2(dns.NewRR("google.com. IN CNAME m.test.google.com")),
 		common.Must2(dns.NewRR("google.com. IN CNAME fake.google.com")),
 		common.Must2(dns.NewRR("google.com. IN CNAME m.test.google.com")),
@@ -134,15 +131,10 @@ func Test_buildReqMsgs(t *testing.T) {
 			IPv6Enable: false,
 			FakeEnable: false,
 		}, nil}, 0},
-		{"name too long", args{strings.Repeat("a", 256), dns_feature.IPOption{
-			IPv4Enable: true,
-			IPv6Enable: true,
-			FakeEnable: false,
-		}, nil}, 0},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got, _ := buildReqMsgs(tt.args.domain, tt.args.option, stubID, tt.args.reqOpts); !(len(got) == tt.want) {
+			if got := buildReqMsgs(tt.args.domain, tt.args.option, stubID, tt.args.reqOpts); !(len(got) == tt.want) {
 				t.Errorf("buildReqMsgs() = %v, want %v", got, tt.want)
 			}
 		})
@@ -17,7 +17,7 @@ import (
 type Holder struct {
 	domainToIP cache.Lru
 	ipRange    *net.IPNet
-	mu         sync.Mutex
+	mu         *sync.Mutex

 	config *FakeDnsPool
 }
@@ -49,7 +49,9 @@ func (fkdns *Holder) Start() error {
 }

 func (fkdns *Holder) Close() error {
-	// nothing to do for now, just wait GC
+	fkdns.domainToIP = nil
+	fkdns.ipRange = nil
+	fkdns.mu = nil
 	return nil
 }

@@ -68,7 +70,7 @@ func NewFakeDNSHolder() (*Holder, error) {
 }

 func NewFakeDNSHolderConfigOnly(conf *FakeDnsPool) (*Holder, error) {
-	return &Holder{config: conf}, nil
+	return &Holder{nil, nil, nil, conf}, nil
 }

 func (fkdns *Holder) initializeFromConfig() error {
@@ -90,6 +92,7 @@ func (fkdns *Holder) initialize(ipPoolCidr string, lruSize int) error {
 	}
 	fkdns.domainToIP = cache.NewLru(lruSize)
 	fkdns.ipRange = ipRange
+	fkdns.mu = new(sync.Mutex)
 	return nil
 }

@@ -100,7 +103,7 @@ func (fkdns *Holder) GetFakeIPForDomain(domain string) []net.Address {
 	if v, ok := fkdns.domainToIP.Get(domain); ok {
 		return []net.Address{v.(net.Address)}
 	}
-	currentTimeMillis := uint64(time.Now().UnixMilli())
+	currentTimeMillis := uint64(time.Now().UnixNano() / 1e6)
 	ones, bits := fkdns.ipRange.Mask.Size()
 	rooms := bits - ones
 	if rooms < 64 {
@@ -199,11 +202,12 @@ func (h *HolderMulti) Start() error {
 }

 func (h *HolderMulti) Close() error {
-	var errs []error
 	for _, v := range h.holders {
-		errs = append(errs, v.Close())
+		if err := v.Close(); err != nil {
+			return errors.New("Cannot close all fake dns pools").Base(err)
+		}
 	}
-	return errors.Combine(errs...)
+	return nil
 }

 func (h *HolderMulti) createHolderGroups() error {
@@ -218,7 +222,7 @@ func (h *HolderMulti) createHolderGroups() error {
 }

 func NewFakeDNSHolderMulti(conf *FakeDnsPoolMulti) (*HolderMulti, error) {
-	holderMulti := &HolderMulti{config: conf}
+	holderMulti := &HolderMulti{nil, conf}
 	if err := holderMulti.createHolderGroups(); err != nil {
 		return nil, err
 	}
@@ -129,16 +129,15 @@ func TestFakeDnsHolderCreateMappingAndRollOver(t *testing.T) {
 }

 func TestFakeDNSMulti(t *testing.T) {
-	fakeMulti, err := NewFakeDNSHolderMulti(
-		&FakeDnsPoolMulti{
-			Pools: []*FakeDnsPool{{
-				IpPool:  "240.0.0.0/12",
-				LruSize: 256,
-			}, {
-				IpPool:  "fddd:c5b4:ff5f:f4f0::/64",
-				LruSize: 256,
-			}},
-		},
+	fakeMulti, err := NewFakeDNSHolderMulti(&FakeDnsPoolMulti{
+		Pools: []*FakeDnsPool{{
+			IpPool:  "240.0.0.0/12",
+			LruSize: 256,
+		}, {
+			IpPool:  "fddd:c5b4:ff5f:f4f0::/64",
+			LruSize: 256,
+		}},
+	},
 	)
 	common.Must(err)

@@ -1,201 +0,0 @@
-package dns
-
-import (
-	"context"
-	"math"
-	"strings"
-
-	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/net"
-	featureDNS "github.com/xtls/xray-core/features/dns"
-	"github.com/xtls/xray-core/features/dns/localdns"
-	lua "github.com/yuin/gopher-lua"
-)
-
-// luaDNSServer adapts configured and local DNS to the same Lua API.
-type luaDNSServer struct {
-	id    string
-	name  string
-	query func(context.Context, string, featureDNS.IPOption) ([]net.IP, uint32, error)
-}
-
-// RegisterLua makes xray.dns available to scripts backed by client.
-func RegisterLua(L *lua.LState, client featureDNS.Client) {
-	var servers []luaDNSServer
-	switch client := client.(type) {
-	case *DNS:
-		servers = luaServers(client)
-	case *localdns.Client:
-		servers = []luaDNSServer{{
-			id:   "localhost",
-			name: "localhost",
-			query: func(_ context.Context, domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-				return client.LookupIP(domain, option)
-			},
-		}}
-	}
-	registerLua(L, servers, client)
-}
-
-// RegisterLua makes xray.dns available to DNS scripts.
-func (s *DNS) RegisterLua(L *lua.LState) {
-	registerLua(L, luaServers(s), nil)
-}
-
-func luaServers(s *DNS) []luaDNSServer {
-	servers := make([]luaDNSServer, len(s.clients))
-	for i, client := range s.clients {
-		servers[i] = luaDNSServer{id: client.id, name: client.Name(), query: client.QueryIP}
-	}
-	return servers
-}
-
-func registerLua(L *lua.LState, servers []luaDNSServer, client featureDNS.Client) {
-	L.PreloadModule("xray.dns", func(L *lua.LState) int {
-		serverList := L.NewTable()
-		for i, client := range servers {
-			server := L.NewTable()
-
-			server.RawSetString("ID", lua.LString(client.id))
-
-			server.RawSetString("Query", L.NewFunction(func(L *lua.LState) int {
-				domain, ok := L.Get(2).(lua.LString)
-				if !ok {
-					L.RaiseError("server:Query requires a domain")
-					return 0
-				}
-				option := featureDNS.IPOption{
-					IPv4Enable: L.CheckBool(3),
-					IPv6Enable: L.CheckBool(4),
-					FakeEnable: L.CheckBool(5),
-				}
-				ctx := L.Context()
-				if ctx == nil {
-					L.RaiseError("server:Query requires an active DNS query")
-					return 0
-				}
-				var ips []net.IP
-				var ttl uint32
-				var err error
-				if !option.FakeEnable && strings.EqualFold(client.name, "FakeDNS") {
-					err = featureDNS.ErrEmptyResponse
-				} else {
-					ips, ttl, err = client.query(ctx, string(domain), option)
-				}
-				addresses := L.NewUserData()
-				addresses.Value = ips
-				L.Push(addresses)
-				L.Push(lua.LNumber(ttl))
-				if err != nil {
-					ud := L.NewUserData()
-					ud.Value = err
-					L.Push(ud)
-				} else {
-					L.Push(lua.LNil)
-				}
-				return 3
-			}))
-			serverList.RawSetInt(i+1, server)
-		}
-
-		module := L.NewTable()
-		if servers != nil {
-			module.RawSetString("Servers", serverList)
-		}
-		if client != nil {
-			module.RawSetString("Query", newLuaClientQuery(L, client))
-		}
-		L.Push(module)
-		return 1
-	})
-}
-
-func newLuaClientQuery(L *lua.LState, client featureDNS.Client) *lua.LFunction {
-	return L.NewFunction(func(L *lua.LState) int {
-		domain, ok := L.Get(1).(lua.LString)
-		if !ok {
-			L.RaiseError("dns.Query requires a domain")
-			return 0
-		}
-		option := featureDNS.IPOption{
-			IPv4Enable: L.CheckBool(2),
-			IPv6Enable: L.CheckBool(3),
-			FakeEnable: L.CheckBool(4),
-		}
-		if L.Context() == nil {
-			L.RaiseError("dns.Query requires an active DNS query")
-			return 0
-		}
-		ips, ttl, err := client.LookupIP(string(domain), option)
-		addresses := L.NewUserData()
-		addresses.Value = ips
-		L.Push(addresses)
-		L.Push(lua.LNumber(ttl))
-		if err != nil {
-			ud := L.NewUserData()
-			ud.Value = err
-			L.Push(ud)
-		} else {
-			L.Push(lua.LNil)
-		}
-		return 3
-	})
-}
-
-// CallLuaHook invokes HandleDNSQuery in the supplied state.
-// Returned slices and IP bytes may share storage with DNS caches or matcher inputs.
-func (s *DNS) CallLuaHook(L *lua.LState, ctx context.Context, domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-	previous, top := L.Context(), L.GetTop()
-	L.SetContext(ctx)
-	defer func() {
-		L.SetTop(top)
-		if previous == nil {
-			L.RemoveContext()
-		} else {
-			L.SetContext(previous)
-		}
-	}()
-	fn := L.GetGlobal("HandleDNSQuery")
-	if fn.Type() != lua.LTFunction {
-		return nil, 0, errors.New("DNS script must define HandleDNSQuery(domain, ipv4, ipv6, fake)")
-	}
-	if err := L.CallByParam(lua.P{Fn: fn, NRet: 3, Protect: true},
-		lua.LString(strings.ToLower(domain)), lua.LBool(option.IPv4Enable),
-		lua.LBool(option.IPv6Enable), lua.LBool(option.FakeEnable)); err != nil {
-		return nil, 0, err
-	}
-	return readLuaDNSResult(L.Get(-3), L.Get(-2), L.Get(-1))
-}
-
-func readLuaDNSResult(addresses, ttlValue, errorValue lua.LValue) ([]net.IP, uint32, error) {
-	if errorValue != lua.LNil {
-		if ud, ok := errorValue.(*lua.LUserData); ok {
-			if err, ok := ud.Value.(error); ok {
-				return nil, 0, err
-			}
-		}
-		if s, ok := errorValue.(lua.LString); ok {
-			return nil, 0, errors.New(string(s))
-		}
-		return nil, 0, errors.New("DNS script error must be an error or string")
-	}
-	ttl, ok := ttlValue.(lua.LNumber)
-	if !ok || ttl < 0 || ttl > math.MaxUint32 || math.Trunc(float64(ttl)) != float64(ttl) {
-		return nil, 0, errors.New("DNS script returned invalid TTL")
-	}
-	if addresses == lua.LNil {
-		return nil, 0, featureDNS.ErrEmptyResponse
-	}
-	ud, ok := addresses.(*lua.LUserData)
-	if !ok {
-		return nil, 0, errors.New("DNS script IPs must be native IP slice userdata")
-	}
-	ips, ok := ud.Value.([]net.IP)
-	if !ok {
-		return nil, 0, errors.New("DNS script IPs must be native IP slice userdata")
-	}
-	if len(ips) == 0 {
-		return nil, 0, featureDNS.ErrEmptyResponse
-	}
-	return ips, uint32(ttl), nil
-}
@@ -1,296 +0,0 @@
-package dns
-
-import (
-	"context"
-	go_errors "errors"
-	"math"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/xtls/xray-core/common/geodata"
-	"github.com/xtls/xray-core/common/net"
-	featureDNS "github.com/xtls/xray-core/features/dns"
-	"github.com/xtls/xray-core/features/dns/localdns"
-	lua "github.com/yuin/gopher-lua"
-)
-
-func TestReadLuaDNSResult(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	want := []net.IP{net.ParseIP("8.8.8.8"), {127, 0, 0, 1}, net.ParseIP("::1")}
-	addresses := L.NewUserData()
-	addresses.Value = want
-	ips, ttl, err := readLuaDNSResult(addresses, lua.LNumber(45), lua.LNil)
-	if err != nil || ttl != 45 || len(ips) != len(want) {
-		t.Fatalf("readLuaDNSResult() = %v, TTL %d, %v", ips, ttl, err)
-	}
-	for i := range want {
-		if !ips[i].Equal(want[i]) {
-			t.Fatalf("IP %d = %v, want %v", i, ips[i], want[i])
-		}
-	}
-}
-
-func TestReadLuaDNSResultValidation(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-
-	for _, tc := range []struct {
-		name   string
-		change func(*[3]lua.LValue)
-		want   string
-	}{
-		{"fractional TTL", func(v *[3]lua.LValue) { v[1] = lua.LNumber(1.5) }, "invalid TTL"},
-		{"oversized TTL", func(v *[3]lua.LValue) { v[1] = lua.LNumber(4294967296) }, "invalid TTL"},
-		{"negative TTL", func(v *[3]lua.LValue) { v[1] = lua.LNumber(-1) }, "invalid TTL"},
-		{"NaN TTL", func(v *[3]lua.LValue) { v[1] = lua.LNumber(math.NaN()) }, "invalid TTL"},
-		{"missing TTL", func(v *[3]lua.LValue) { v[1] = lua.LNil }, "invalid TTL"},
-		{"string IPs", func(v *[3]lua.LValue) { v[0] = lua.LString("127.0.0.1") }, "native IP slice"},
-		{"wrong userdata", func(v *[3]lua.LValue) { v[0].(*lua.LUserData).Value = net.ParseIP("127.0.0.1") }, "native IP slice"},
-		{"script error", func(v *[3]lua.LValue) { v[2] = lua.LString("blocked by script") }, "blocked by script"},
-		{"invalid error", func(v *[3]lua.LValue) { v[2] = lua.LTrue }, "error or string"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			addresses := L.NewUserData()
-			addresses.Value = []net.IP{net.ParseIP("127.0.0.1")}
-			values := [3]lua.LValue{addresses, lua.LNumber(60), lua.LNil}
-			tc.change(&values)
-			_, _, err := readLuaDNSResult(values[0], values[1], values[2])
-			if err == nil || !strings.Contains(err.Error(), tc.want) {
-				t.Fatalf("readLuaDNSResult error = %v, want %q", err, tc.want)
-			}
-		})
-	}
-
-	addresses := L.NewUserData()
-	addresses.Value = []net.IP(nil)
-	for _, empty := range []lua.LValue{addresses, lua.LNil} {
-		if _, _, err := readLuaDNSResult(empty, lua.LNumber(0), lua.LNil); !go_errors.Is(err, featureDNS.ErrEmptyResponse) {
-			t.Fatalf("empty result error = %v, want ErrEmptyResponse", err)
-		}
-	}
-	wantErr := go_errors.New("upstream failed")
-	errorValue := L.NewUserData()
-	errorValue.Value = wantErr
-	if _, _, err := readLuaDNSResult(lua.LNil, lua.LNil, errorValue); err != wantErr {
-		t.Fatalf("upstream error = %v, want original error %v", err, wantErr)
-	}
-}
-
-func TestCallLuaHookCancellation(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	if err := L.DoString(`function HandleDNSQuery(domain, ipv4, ipv6, fake) while true do end end`); err != nil {
-		t.Fatal(err)
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-	defer cancel()
-	_, _, err := (&DNS{}).CallLuaHook(L, ctx, "example.com", featureDNS.IPOption{IPv4Enable: true})
-	if err == nil {
-		t.Fatal("CallLuaHook did not stop after context cancellation")
-	}
-	if L.Context() != nil {
-		t.Fatal("CallLuaHook left the canceled context on the Lua state")
-	}
-}
-
-func TestCallLuaHookNormalizesDomain(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	addresses := L.NewUserData()
-	addresses.Value = []net.IP{net.ParseIP("127.0.0.1")}
-	L.SetGlobal("ips", addresses)
-	if err := L.DoString(`
-		function HandleDNSQuery(domain, ipv4, ipv6, fake)
-			assert(domain == "example.com")
-			assert(ipv4 and not ipv6 and not fake)
-			return ips, 60, nil
-		end
-	`); err != nil {
-		t.Fatal(err)
-	}
-	s := &DNS{}
-	if _, _, err := s.CallLuaHook(L, context.Background(), "ExAmPlE.CoM", featureDNS.IPOption{IPv4Enable: true}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCallLuaHookRestoresState(t *testing.T) {
-	for _, tc := range []struct {
-		name    string
-		body    string
-		wantErr bool
-	}{
-		{"success", `return ips, 60`, false},
-		{"error", `error("failed")`, true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			L := lua.NewState()
-			defer L.Close()
-			addresses := L.NewUserData()
-			addresses.Value = []net.IP{net.ParseIP("127.0.0.1")}
-			L.SetGlobal("ips", addresses)
-			if err := L.DoString("function HandleDNSQuery() " + tc.body + " end"); err != nil {
-				t.Fatal(err)
-			}
-			previous, cancel := context.WithCancel(context.Background())
-			defer cancel()
-			L.SetContext(previous)
-			L.Push(lua.LTrue)
-			_, _, err := (&DNS{}).CallLuaHook(L, context.Background(), "example.com", featureDNS.IPOption{IPv4Enable: true})
-			if (err != nil) != tc.wantErr {
-				t.Fatalf("hook error = %v, want error %t", err, tc.wantErr)
-			}
-			if L.Context() != previous || L.GetTop() != 1 || L.Get(1) != lua.LTrue {
-				t.Fatal("hook did not restore the previous context and stack")
-			}
-		})
-	}
-}
-
-func TestLuaDNSServerQuery(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	geodata.RegisterLua(L)
-	option := featureDNS.IPOption{IPv4Enable: true}
-	ips := []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("8.8.8.8")}
-	server := &DNS{clients: []*Client{{server: &benchmarkLuaNameServer{ips: ips}, ipOption: &option, timeoutMs: time.Second}}}
-	server.RegisterLua(L)
-	if err := L.DoString(`
-local server = require("xray.dns").Servers[1]
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.0/8")
-function HandleDNSQuery(domain, ipv4, ipv6, fake)
-    local ips, ttl, err = server:Query(domain, ipv4, ipv6, fake)
-    assert(type(ips) == "userdata" and not err)
-    assert(matcher:AnyMatch(ips))
-    local matched = matcher:FilterIPs(ips)
-    return matched, ttl, err
-end
-`); err != nil {
-		t.Fatal(err)
-	}
-	got, ttl, err := server.CallLuaHook(L, context.Background(), "example.com", option)
-	if err != nil || ttl != 60 || len(got) != 1 || !got[0].Equal(ips[0]) {
-		t.Fatalf("server query = %v, TTL %d, %v", got, ttl, err)
-	}
-}
-
-type luaDNSClient struct {
-	featureDNS.Client
-	lookup func(string, featureDNS.IPOption) ([]net.IP, uint32, error)
-}
-
-func (c *luaDNSClient) LookupIP(domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-	return c.lookup(domain, option)
-}
-
-func TestLuaDNSClientQuery(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	L.SetContext(context.Background())
-	defer L.RemoveContext()
-	geodata.RegisterLua(L)
-	want := []net.IP{{127, 0, 0, 1}}
-	client := &luaDNSClient{lookup: func(domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-		if domain != "MiXeD.Example." || !option.IPv4Enable || option.IPv6Enable || !option.FakeEnable {
-			t.Fatalf("dns.Query arguments = %q, %+v", domain, option)
-		}
-		return want, 42, nil
-	}}
-	RegisterLua(L, client)
-	if err := L.DoString(`
-local dns = require("xray.dns")
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.1")
-assert(dns.Servers == nil)
-ips, ttl, err = dns.Query("MiXeD.Example.", true, false, true)
-assert(not err and ttl == 42 and matcher:AnyMatch(ips))
-`); err != nil {
-		t.Fatal(err)
-	}
-	got := L.GetGlobal("ips").(*lua.LUserData).Value.([]net.IP)
-	if &got[0] != &want[0] {
-		t.Fatal("dns.Query copied the IP slice")
-	}
-}
-
-func TestLuaDNSLocalClient(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	L.SetContext(context.Background())
-	defer L.RemoveContext()
-	RegisterLua(L, localdns.New())
-	if err := L.DoString(`
-local dns = require("xray.dns")
-assert(dns.Servers[1].ID == "localhost")
-serverIPs, _, serverErr = dns.Servers[1]:Query("127.0.0.1", true, false, false)
-clientIPs, _, clientErr = dns.Query("127.0.0.1", true, false, false)
-assert(not serverErr and not clientErr)
-`); err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range []string{"serverIPs", "clientIPs"} {
-		ips := L.GetGlobal(name).(*lua.LUserData).Value.([]net.IP)
-		if len(ips) != 1 || !ips[0].Equal(net.ParseIP("127.0.0.1")) {
-			t.Fatalf("%s = %v", name, ips)
-		}
-	}
-}
-
-type benchmarkLuaNameServer struct {
-	ips []net.IP
-}
-
-func (*benchmarkLuaNameServer) Name() string         { return "benchmark" }
-func (*benchmarkLuaNameServer) IsDisableCache() bool { return true }
-func (s *benchmarkLuaNameServer) QueryIP(context.Context, string, featureDNS.IPOption) ([]net.IP, uint32, error) {
-	return s.ips, 60, nil
-}
-
-// BenchmarkLuaDNSHookCall isolates a preloaded Lua hook and its server:Query bridge.
-// The direct case measures the same DNS client without Lua.
-func BenchmarkLuaDNSHookCall(b *testing.B) {
-	option := featureDNS.IPOption{IPv4Enable: true}
-	ip := net.ParseIP("127.0.0.1")
-	upstream := &benchmarkLuaNameServer{ips: []net.IP{ip}}
-	client := &Client{server: upstream, ipOption: &option, timeoutMs: time.Second}
-	server := &DNS{clients: []*Client{client}}
-	L := lua.NewState()
-	defer L.Close()
-	server.RegisterLua(L)
-	if err := L.DoString(`
-local server = require("xray.dns").Servers[1]
-function HandleDNSQuery(domain, ipv4, ipv6, fake)
-    return server:Query(domain, ipv4, ipv6, fake)
-end
-`); err != nil {
-		b.Fatal(err)
-	}
-
-	ctx := context.Background()
-	for _, bench := range []struct {
-		name  string
-		query func() ([]net.IP, uint32, error)
-	}{
-		{"direct", func() ([]net.IP, uint32, error) { return client.QueryIP(ctx, "example.com", option) }},
-		{"lua_hook", func() ([]net.IP, uint32, error) { return server.CallLuaHook(L, ctx, "example.com", option) }},
-	} {
-		b.Run(bench.name, func(b *testing.B) {
-			b.ReportAllocs()
-			b.ResetTimer()
-			var ips []net.IP
-			var ttl uint32
-			var err error
-			for i := 0; i < b.N; i++ {
-				ips, ttl, err = bench.query()
-				if err != nil {
-					b.Fatal(err)
-				}
-			}
-			b.StopTimer()
-			if ttl != 60 || len(ips) != 1 || !ips[0].Equal(ip) {
-				b.Fatalf("query() = %v, TTL %d; want %v, TTL 60", ips, ttl, ip)
-			}
-		})
-	}
-}
@@ -10,7 +10,6 @@ import (
 	"github.com/xtls/xray-core/common/geodata"
 	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/session"
-	"github.com/xtls/xray-core/common/utils"
 	"github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/dns"
 	"github.com/xtls/xray-core/features/routing"
@@ -29,7 +28,6 @@ type Server interface {

 // Client is the interface for DNS client.
 type Client struct {
-	id            string
 	server        Server
 	skipFallback  bool
 	expectedIPs   geodata.IPMatcher
@@ -98,7 +96,7 @@ func NewClient(
 	ipOption dns.IPOption,
 	updateRules func(bool),
 ) (*Client, error) {
-	client := &Client{id: ns.Id}
+	client := &Client{}
 	err := core.RequireFeatures(ctx, func(dispatcher routing.Dispatcher) error {
 		// Create a new server for each client for now
 		server, err := NewServer(ctx, ns.Address.AsDestination(), dispatcher, disableCache, serveStale, serveExpiredTTL, clientIP)
@@ -136,7 +134,7 @@ func NewClient(
 			}
 		}

-		timeoutMs := 4000 * time.Millisecond
+		var timeoutMs = 4000 * time.Millisecond
 		if ns.TimeoutMs > 0 {
 			timeoutMs = time.Duration(ns.TimeoutMs) * time.Millisecond
 		}
@@ -168,7 +166,7 @@ func (c *Client) Name() string {
 // QueryIP sends DNS query to the name server with the client's IP.
 func (c *Client) QueryIP(ctx context.Context, domain string, option dns.IPOption) ([]net.IP, uint32, error) {
 	if c.checkSystem {
-		supportIPv4, supportIPv6 := utils.CheckRoutes()
+		supportIPv4, supportIPv6 := checkRoutes()
 		option.IPv4Enable = option.IPv4Enable && supportIPv4
 		option.IPv6Enable = option.IPv6Enable && supportIPv6
 	} else {
@@ -137,32 +137,14 @@ func (s *DoHNameServer) sendQuery(ctx context.Context, noResponseErrCh chan<- er
 	if s.Name()+"." == "DOH//"+fqdn {
 		errors.LogError(ctx, s.Name(), " tries to resolve itself! Use IP or set \"hosts\" instead")
 		if noResponseErrCh != nil {
-			err := errors.New("tries to resolve itself!", s.Name())
-			if option.IPv4Enable {
-				noResponseErrCh <- err
-			}
-			if option.IPv6Enable {
-				noResponseErrCh <- err
-			}
+			noResponseErrCh <- errors.New("tries to resolve itself!", s.Name())
 		}
 		return
 	}

 	// As we don't want our traffic pattern looks like DoH, we use Random-Length Padding instead of Block-Length Padding recommended in RFC 8467
 	// Although DoH server like 1.1.1.1 will pad the response to Block-Length 468, at least it is better than no padding for response at all
-	reqs, err := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, int(crypto.RandBetween(100, 300))))
-	if err != nil {
-		errors.LogErrorInner(ctx, err, "failed to build dns query for ", fqdn)
-		if noResponseErrCh != nil {
-			if option.IPv4Enable {
-				noResponseErrCh <- err
-			}
-			if option.IPv6Enable {
-				noResponseErrCh <- err
-			}
-		}
-		return
-	}
+	reqs := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, int(crypto.RandBetween(100, 300))))

 	var deadline time.Time
 	if d, ok := ctx.Deadline(); ok {
@@ -18,6 +18,7 @@ type LocalNameServer struct {

 // QueryIP implements Server.
 func (s *LocalNameServer) QueryIP(ctx context.Context, domain string, option dns.IPOption) (ips []net.IP, ttl uint32, err error) {
+
 	start := time.Now()
 	ips, ttl, err = s.client.LookupIP(domain, option)

@@ -49,5 +50,5 @@ func NewLocalNameServer() *LocalNameServer {

 // NewLocalDNSClient creates localdns client object for directly lookup in system DNS.
 func NewLocalDNSClient(ipOption dns.IPOption) *Client {
-	return &Client{id: "localhost", server: NewLocalNameServer(), ipOption: &ipOption}
+	return &Client{server: NewLocalNameServer(), ipOption: &ipOption}
 }
@@ -78,19 +78,7 @@ func (s *QUICNameServer) getCacheController() *CacheController { return s.cacheC
 func (s *QUICNameServer) sendQuery(ctx context.Context, noResponseErrCh chan<- error, fqdn string, option dns_feature.IPOption) {
 	errors.LogInfo(ctx, s.Name(), " querying: ", fqdn)

-	reqs, err := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))
-	if err != nil {
-		errors.LogErrorInner(ctx, err, "failed to build dns query for ", fqdn)
-		if noResponseErrCh != nil {
-			if option.IPv4Enable {
-				noResponseErrCh <- err
-			}
-			if option.IPv6Enable {
-				noResponseErrCh <- err
-			}
-		}
-		return
-	}
+	reqs := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))

 	var deadline time.Time
 	if d, ok := ctx.Deadline(); ok {
@@ -113,19 +113,7 @@ func (s *TCPNameServer) getCacheController() *CacheController {
 func (s *TCPNameServer) sendQuery(ctx context.Context, noResponseErrCh chan<- error, fqdn string, option dns_feature.IPOption) {
 	errors.LogInfo(ctx, s.Name(), " querying DNS for: ", fqdn)

-	reqs, err := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))
-	if err != nil {
-		errors.LogErrorInner(ctx, err, "failed to build dns query for ", fqdn)
-		if noResponseErrCh != nil {
-			if option.IPv4Enable {
-				noResponseErrCh <- err
-			}
-			if option.IPv6Enable {
-				noResponseErrCh <- err
-			}
-		}
-		return
-	}
+	reqs := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))

 	var deadline time.Time
 	if d, ok := ctx.Deadline(); ok {
@@ -131,6 +131,8 @@ func (s *ClassicNameServer) HandleResponse(ctx context.Context, packet *udp_prot
 			newReq.msg = &newMsg
 			s.addPendingRequest(&newReq)
 			b, _ := dns.PackMessage(newReq.msg)
+			copyDest := net.UDPDestination(s.address.Address, s.address.Port)
+			b.UDP = &copyDest
 			s.udpServer.Dispatch(toDnsContext(newReq.ctx, s.address.String()), *s.address, b)
 			return
 		}
@@ -161,19 +163,7 @@ func (s *ClassicNameServer) getCacheController() *CacheController {
 func (s *ClassicNameServer) sendQuery(ctx context.Context, noResponseErrCh chan<- error, fqdn string, option dns_feature.IPOption) {
 	errors.LogInfo(ctx, s.Name(), " querying DNS for: ", fqdn)

-	reqs, err := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))
-	if err != nil {
-		errors.LogErrorInner(ctx, err, "failed to build dns query for ", fqdn)
-		if noResponseErrCh != nil {
-			if option.IPv4Enable {
-				noResponseErrCh <- err
-			}
-			if option.IPv6Enable {
-				noResponseErrCh <- err
-			}
-		}
-		return
-	}
+	reqs := buildReqMsgs(fqdn, option, s.newReqID, genEDNS0Options(s.clientIP, 0))

 	for _, req := range reqs {
 		udpReq := &udpDnsRequest{
@@ -189,6 +179,8 @@ func (s *ClassicNameServer) sendQuery(ctx context.Context, noResponseErrCh chan<
 			}
 			return
 		}
+		copyDest := net.UDPDestination(s.address.Address, s.address.Port)
+		b.UDP = &copyDest
 		s.udpServer.Dispatch(toDnsContext(ctx, s.address.String()), *s.address, b)
 	}
 }
@@ -1,73 +0,0 @@
-package dns
-
-import (
-	"context"
-	"time"
-
-	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/geodata"
-	"github.com/xtls/xray-core/common/log"
-	luamgr "github.com/xtls/xray-core/common/lua"
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/features/dns"
-	lua "github.com/yuin/gopher-lua"
-)
-
-const scriptExecutionTimeout = 10 * time.Second
-
-type scriptEngine struct {
-	dns  *DNS
-	pool *luamgr.Pool
-}
-
-func newScriptEngine(path string, server *DNS) (*scriptEngine, error) {
-	program, err := luamgr.CompileFile(path)
-	if err != nil {
-		return nil, err
-	}
-	e := &scriptEngine{dns: server}
-	e.pool, err = luamgr.NewPool(server.ctx, func(poolCtx context.Context) (*lua.LState, error) {
-		initCtx, cancel := context.WithTimeout(poolCtx, scriptExecutionTimeout)
-		defer cancel()
-		L, err := program.NewState(initCtx, func(L *lua.LState) {
-			geodata.RegisterLua(L)
-			log.RegisterLua(L)
-			server.RegisterLua(L)
-		})
-		if err != nil {
-			return nil, err
-		}
-		if L.GetGlobal("HandleDNSQuery").Type() != lua.LTFunction {
-			L.Close()
-			return nil, errors.New("DNS script must define HandleDNSQuery(domain, ipv4, ipv6, fake)")
-		}
-		return L, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	errors.LogInfo(server.ctx, "DNS script initialized from ", path)
-	return e, nil
-}
-
-func (e *scriptEngine) close() {
-	e.pool.Close()
-}
-
-func (e *scriptEngine) query(domain string, option dns.IPOption) ([]net.IP, uint32, error) {
-	L, err := e.pool.Acquire()
-	if err != nil {
-		return nil, 0, err
-	}
-	reusable := false
-	defer func() {
-		e.pool.Release(L, reusable)
-	}()
-	queryCtx, cancel := context.WithTimeout(e.pool.Context(), scriptExecutionTimeout)
-	defer cancel()
-	ips, ttl, err := e.dns.CallLuaHook(L, queryCtx, domain, option)
-	if err == nil {
-		reusable = true
-	}
-	return ips, ttl, err
-}
@@ -1,197 +0,0 @@
-package dns
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/xtls/xray-core/common/net"
-	featureDNS "github.com/xtls/xray-core/features/dns"
-)
-
-type geoIPScriptNameServer struct {
-	name    string
-	answers map[string]net.IP
-	ttl     uint32
-	calls   int
-}
-
-func (s *geoIPScriptNameServer) Name() string         { return s.name }
-func (s *geoIPScriptNameServer) IsDisableCache() bool { return true }
-
-func (s *geoIPScriptNameServer) QueryIP(ctx context.Context, domain string, _ featureDNS.IPOption) ([]net.IP, uint32, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, 0, err
-	}
-	s.calls++
-	ip, ok := s.answers[domain]
-	if !ok {
-		return nil, 0, featureDNS.ErrEmptyResponse
-	}
-	return []net.IP{ip}, s.ttl, nil
-}
-
-func TestDNSScriptGeoIPFallback(t *testing.T) {
-	t.Setenv("xray.location.asset", filepath.Join("..", "..", "resources"))
-	script := `
-local servers = require("xray.dns").Servers
-local us_ips = require("xray.geodata").BuildIPMatcher("geoip:us")
-
-local by_id = {}
-for _, server in ipairs(servers) do
-    by_id[server.ID] = server
-end
-assert(by_id.primary and by_id.fallback, "primary and fallback DNS servers are required")
-
-function HandleDNSQuery(domain, ipv4, ipv6, fake)
-    local ips, ttl, err = by_id.primary:Query(domain, ipv4, ipv6, fake)
-    if not err and us_ips:AnyMatch(ips) then
-        return ips, ttl, nil
-    end
-    return by_id.fallback:Query(domain, ipv4, ipv6, fake)
-end
-`
-	scriptPath := filepath.Join(t.TempDir(), "geoip_fallback.lua")
-	if err := os.WriteFile(scriptPath, []byte(script), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	primary := &geoIPScriptNameServer{
-		name: "primary",
-		answers: map[string]net.IP{
-			"us.example":    net.ParseIP("2001:4860:4860::8888"),
-			"other.example": net.ParseIP("127.0.0.1"),
-		},
-		ttl: 30,
-	}
-	fallback := &geoIPScriptNameServer{
-		name:    "fallback",
-		answers: map[string]net.IP{"other.example": net.ParseIP("9.9.9.9")},
-		ttl:     60,
-	}
-	option := featureDNS.IPOption{IPv4Enable: true, IPv6Enable: true}
-	hosts, err := NewStaticHosts(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	server := &DNS{
-		ctx:        context.Background(),
-		hosts:      hosts,
-		ipOption:   &option,
-		scriptPath: scriptPath,
-		clients: []*Client{
-			{id: "primary", server: primary, ipOption: &option, timeoutMs: 2 * time.Second},
-			{id: "fallback", server: fallback, ipOption: &option, timeoutMs: 2 * time.Second},
-		},
-	}
-	if err := server.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer server.Close()
-
-	for _, tc := range []struct {
-		domain string
-		ip     net.IP
-		ttl    uint32
-	}{
-		{"Us.Example.", net.ParseIP("2001:4860:4860::8888"), 30},
-		{"other.example", net.ParseIP("9.9.9.9"), 60},
-	} {
-		ips, ttl, err := server.LookupIP(tc.domain, option)
-		if err != nil {
-			t.Fatalf("LookupIP(%q): %v", tc.domain, err)
-		}
-		if ttl != tc.ttl || len(ips) != 1 || !ips[0].Equal(tc.ip) {
-			t.Fatalf("LookupIP(%q) = %v, TTL %d; want %v, TTL %d", tc.domain, ips, ttl, tc.ip, tc.ttl)
-		}
-	}
-	if primary.calls != 2 || fallback.calls != 1 {
-		t.Fatalf("upstream calls: primary %d, fallback %d; want 2 and 1", primary.calls, fallback.calls)
-	}
-}
-
-func TestDNSScriptRejectsInvalidStartup(t *testing.T) {
-	for _, tc := range []struct {
-		name   string
-		script string
-	}{
-		{"syntax", "function HandleDNSQuery("},
-		{"missing hook", "value = 1"},
-		{"top-level error", `error("setup failed")`},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			path := filepath.Join(t.TempDir(), "script.lua")
-			if err := os.WriteFile(path, []byte(tc.script), 0o600); err != nil {
-				t.Fatal(err)
-			}
-			server := &DNS{ctx: context.Background(), scriptPath: path}
-			if err := server.Start(); err == nil {
-				t.Fatal("Start accepted an invalid DNS script")
-			}
-			if server.script != nil {
-				t.Fatal("Start retained a script engine after failure")
-			}
-		})
-	}
-}
-
-func TestDNSScriptHookErrorAndFakeDNSOption(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "script.lua")
-	script := `
-local server = require("xray.dns").Servers[1]
-local log = require("xray.log")
-log.Info("DNS script loaded")
-function HandleDNSQuery(domain, ipv4, ipv6, fake)
-    log.Debug("DNS query: ", domain)
-    if domain == "bad.example" then error("script failure") end
-    local ips, ttl, err = server:Query(domain, ipv4, ipv6, fake)
-    if err then log.Error("DNS failed: ", err) end
-    return ips, ttl, err
-end
-`
-	if err := os.WriteFile(path, []byte(script), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	option := featureDNS.IPOption{IPv4Enable: true}
-	hosts, err := NewStaticHosts(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	upstream := &geoIPScriptNameServer{
-		name:    "FakeDNS",
-		answers: map[string]net.IP{"good.example": net.ParseIP("198.18.0.1")},
-		ttl:     30,
-	}
-	server := &DNS{
-		ctx:        context.Background(),
-		hosts:      hosts,
-		ipOption:   &option,
-		scriptPath: path,
-		clients:    []*Client{{id: "fake", server: upstream, ipOption: &option, timeoutMs: time.Second}},
-	}
-	if err := server.Start(); err != nil {
-		t.Fatal(err)
-	}
-	defer server.Close()
-
-	if _, _, err := server.LookupIP("bad.example", option); err == nil || !strings.Contains(err.Error(), "script failure") {
-		t.Fatalf("hook failure = %v, want script failure", err)
-	}
-	if _, _, err := server.LookupIP("good.example", option); err != featureDNS.ErrEmptyResponse {
-		t.Fatalf("FakeDNS without FakeEnable = %v, want ErrEmptyResponse", err)
-	}
-	if upstream.calls != 0 {
-		t.Fatalf("FakeDNS was queried without FakeEnable: %d calls", upstream.calls)
-	}
-	withFake := featureDNS.IPOption{IPv4Enable: true, FakeEnable: true}
-	ips, ttl, err := server.LookupIP("good.example", withFake)
-	if err != nil || ttl != 30 || len(ips) != 1 || !ips[0].Equal(net.ParseIP("198.18.0.1")) {
-		t.Fatalf("FakeDNS with FakeEnable = %v, TTL %d, %v", ips, ttl, err)
-	}
-	if upstream.calls != 1 {
-		t.Fatalf("FakeDNS query count = %d, want 1", upstream.calls)
-	}
-}
@@ -2,7 +2,6 @@ package geodata

 import (
 	"context"
-	"crypto/tls"
 	go_errors "errors"
 	"io"
 	"net/http"
@@ -10,7 +9,6 @@ import (
 	"path/filepath"
 	"time"

-	utls "github.com/refraction-networking/utls"
 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/platform/filesystem"
@@ -18,7 +16,6 @@ import (
 	"github.com/xtls/xray-core/common/utils"
 	"github.com/xtls/xray-core/features/routing"
 	"github.com/xtls/xray-core/transport/internet/tagged"
-	"golang.org/x/net/http2"
 )

 const idleTimeout = 30 * time.Second
@@ -29,9 +26,8 @@ type stage struct {
 }

 type downloader struct {
-	ctx         context.Context
-	httpClient  *http.Client
-	httpsClient *http.Client
+	ctx    context.Context
+	client *http.Client
 }

 type idleConn struct {
@@ -57,84 +53,52 @@ func (c *idleConn) Write(b []byte) (int, error) {

 func newDownloader(ctx context.Context, dispatcher routing.Dispatcher, outbound string) *downloader {
 	return &downloader{
-		ctx:         ctx,
-		httpClient:  newClient(ctx, dispatcher, outbound, false),
-		httpsClient: newClient(ctx, dispatcher, outbound, true),
+		ctx:    ctx,
+		client: newClient(ctx, dispatcher, outbound),
 	}
 }

-func newClient(baseCtx context.Context, dispatcher routing.Dispatcher, outbound string, isHTTPS bool) *http.Client {
-	dial := func(ctx context.Context, network, address string) (net.Conn, error) {
-		var conn net.Conn
-		err := task.Run(ctx, func() error {
-			if tagged.Dialer == nil {
-				return errors.New("tagged dialer is not initialized")
-			}
-			dest, err := net.ParseDestination(network + ":" + address)
-			if err != nil {
-				return errors.New("cannot understand address").Base(err)
-			}
-			c, err := tagged.Dialer(baseCtx, dispatcher, dest, outbound)
-			if err != nil {
-				return errors.New("cannot dial remote address ", dest).Base(err)
-			}
-			conn = c
-			return nil
-		})
-		if err != nil {
-			return nil, errors.New("cannot finish connection").Base(err)
-		}
-		return &idleConn{
-			Conn: conn,
-		}, nil
-	}
-	if isHTTPS {
-		return &http.Client{
-			Transport: &http2.Transport{
-				DialTLSContext: func(ctx context.Context, network string, address string, cfg *tls.Config) (net.Conn, error) {
-					conn, err := dial(ctx, network, address)
+func newClient(baseCtx context.Context, dispatcher routing.Dispatcher, outbound string) *http.Client {
+	return &http.Client{
+		Transport: &http.Transport{
+			Proxy:             nil,
+			DisableKeepAlives: true,
+			DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
+				var conn net.Conn
+				err := task.Run(ctx, func() error {
+					if tagged.Dialer == nil {
+						return errors.New("tagged dialer is not initialized")
+					}
+					dest, err := net.ParseDestination(network + ":" + address)
 					if err != nil {
-						return nil, err
+						return errors.New("cannot understand address").Base(err)
 					}
-					host, _, _ := net.SplitHostPort(address)
-					tlsConn := utls.UClient(conn, &utls.Config{ServerName: host}, utls.HelloChrome_Auto)
-					handshakeCtx, cancel := context.WithTimeout(ctx, idleTimeout)
-					defer cancel()
-					if err := tlsConn.HandshakeContext(handshakeCtx); err != nil {
-						conn.Close()
-						return nil, err
+					c, err := tagged.Dialer(baseCtx, dispatcher, dest, outbound)
+					if err != nil {
+						return errors.New("cannot dial remote address ", dest).Base(err)
 					}
-					return tlsConn, nil
-				},
-			},
-			CheckRedirect: func(req *http.Request, via []*http.Request) error {
-				if req.URL.Scheme != "https" {
-					return errors.New("redirected to non-https URL: ", req.URL.String())
+					conn = c
+					return nil
+				})
+				if err != nil {
+					return nil, errors.New("cannot finish connection").Base(err)
 				}
-				if len(via) >= 10 {
-					return errors.New("stopped after 10 redirects")
-				}
-				return nil
+				return &idleConn{
+					Conn: conn,
+				}, nil
 			},
-		}
-	} else {
-		return &http.Client{
-			Transport: &http.Transport{
-				Proxy:                 nil,
-				DisableKeepAlives:     true,
-				DialContext:           dial,
-				ResponseHeaderTimeout: idleTimeout,
-			},
-			CheckRedirect: func(req *http.Request, via []*http.Request) error {
-				if req.URL.Scheme != "https" {
-					return errors.New("redirected to non-https URL: ", req.URL.String())
-				}
-				if len(via) >= 10 {
-					return errors.New("stopped after 10 redirects")
-				}
-				return nil
-			},
-		}
+			TLSHandshakeTimeout:   idleTimeout,
+			ResponseHeaderTimeout: idleTimeout,
+		},
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			if req.URL.Scheme != "https" {
+				return errors.New("redirected to non-https URL: ", req.URL.String())
+			}
+			if len(via) >= 10 {
+				return errors.New("stopped after 10 redirects")
+			}
+			return nil
+		},
 	}
 }

@@ -196,13 +160,7 @@ func (d *downloader) fetch(rawURL string, writer io.Writer) error {
 	}
 	utils.TryDefaultHeadersWith(req.Header, "nav")

-	var client *http.Client
-	if req.URL.Scheme == "https" {
-		client = d.httpsClient
-	} else {
-		client = d.httpClient
-	}
-	resp, err := client.Do(req)
+	resp, err := d.client.Do(req)
 	if err != nil {
 		return err
 	}
@@ -2,18 +2,15 @@ package metrics

 import (
 	"context"
-	"encoding/json"
-	stderrors "errors"
 	"expvar"
-	stdnet "net"
 	"net/http"
-	"net/http/pprof"
+	_ "net/http/pprof"
 	"strings"

 	"github.com/xtls/xray-core/app/observatory"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
-	xnet "github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/signal/done"
 	"github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/extension"
@@ -24,17 +21,15 @@ import (
 type MetricsHandler struct {
 	ohm          outbound.Manager
 	statsManager feature_stats.Manager
-	ctx          context.Context
+	observatory  extension.Observatory
 	tag          string
 	listen       string
-	tcpListener  xnet.Listener
-	listener     *OutboundListener
+	tcpListener  net.Listener
 }

 // NewMetricsHandler creates a new MetricsHandler based on the given config.
 func NewMetricsHandler(ctx context.Context, config *Config) (*MetricsHandler, error) {
 	c := &MetricsHandler{
-		ctx:    ctx,
 		tag:    config.Tag,
 		listen: config.Listen,
 	}
@@ -42,6 +37,46 @@ func NewMetricsHandler(ctx context.Context, config *Config) (*MetricsHandler, er
 		c.statsManager = sm
 		c.ohm = om
 	}))
+	expvar.Publish("stats", expvar.Func(func() interface{} {
+		resp := map[string]map[string]map[string]int64{
+			"inbound":  {},
+			"outbound": {},
+			"user":     {},
+		}
+		c.statsManager.VisitCounters(func(name string, counter feature_stats.Counter) bool {
+			nameSplit := strings.Split(name, ">>>")
+			typeName, tagOrUser, direction := nameSplit[0], nameSplit[1], nameSplit[3]
+			if item, found := resp[typeName][tagOrUser]; found {
+				item[direction] = counter.Value()
+			} else {
+				resp[typeName][tagOrUser] = map[string]int64{
+					direction: counter.Value(),
+				}
+			}
+			return true
+		})
+		return resp
+	}))
+	expvar.Publish("observatory", expvar.Func(func() interface{} {
+		if c.observatory == nil {
+			common.Must(core.RequireFeatures(ctx, func(observatory extension.Observatory) error {
+				c.observatory = observatory
+				return nil
+			}))
+			if c.observatory == nil {
+				return nil
+			}
+		}
+		resp := map[string]*observatory.OutboundStatus{}
+		if o, err := c.observatory.GetObservation(context.Background()); err != nil {
+			return err
+		} else {
+			for _, x := range o.(*observatory.ObservationResult).GetStatus() {
+				resp[x.OutboundTag] = x
+			}
+		}
+		return resp
+	}))
 	return c, nil
 }

@@ -50,172 +85,46 @@ func (p *MetricsHandler) Type() interface{} {
 }

 func (p *MetricsHandler) Start() error {
-	handler := p.httpHandler()

 	// direct listen a port if listen is set
 	if p.listen != "" {
-		TCPlistener, err := xnet.Listen("tcp", p.listen)
+		TCPlistener, err := net.Listen("tcp", p.listen)
 		if err != nil {
 			return err
 		}
 		p.tcpListener = TCPlistener
 		errors.LogInfo(context.Background(), "Metrics server listening on ", p.listen)

-		go p.serve(TCPlistener, handler)
-	}
-
-	if p.tag == "" {
-		if p.tcpListener == nil {
-			return errors.New("metrics must have a tag or listen address")
-		}
-		return nil
+		go func() {
+			if err := http.Serve(TCPlistener, http.DefaultServeMux); err != nil {
+				errors.LogErrorInner(context.Background(), err, "failed to start metrics server")
+			}
+		}()
 	}

 	listener := &OutboundListener{
-		buffer: make(chan xnet.Conn, 4),
+		buffer: make(chan net.Conn, 4),
 		done:   done.New(),
 	}
-	p.listener = listener

-	go p.serve(listener, handler)
+	go func() {
+		if err := http.Serve(listener, http.DefaultServeMux); err != nil {
+			errors.LogErrorInner(context.Background(), err, "failed to start metrics server")
+		}
+	}()

 	if err := p.ohm.RemoveHandler(context.Background(), p.tag); err != nil {
 		errors.LogInfo(context.Background(), "failed to remove existing handler")
 	}

-	if err := p.ohm.AddHandler(context.Background(), &Outbound{
+	return p.ohm.AddHandler(context.Background(), &Outbound{
 		tag:      p.tag,
 		listener: listener,
-	}); err != nil {
-		if closeErr := p.Close(); closeErr != nil {
-			errors.LogErrorInner(context.Background(), closeErr, "failed to close metrics server after start failure")
-		}
-		return err
-	}
-
-	return nil
+	})
 }

 func (p *MetricsHandler) Close() error {
-	var errs []error
-	if p.tcpListener != nil {
-		errs = append(errs, p.tcpListener.Close())
-		p.tcpListener = nil
-	}
-	if p.listener != nil {
-		errs = append(errs, p.listener.Close())
-		p.listener = nil
-	}
-	if p.ohm != nil && p.tag != "" {
-		if err := p.ohm.RemoveHandler(context.Background(), p.tag); err != nil {
-			errors.LogInfo(context.Background(), "failed to remove metrics handler")
-		}
-	}
-	return errors.Combine(errs...)
-}
-
-func (p *MetricsHandler) serve(listener xnet.Listener, handler http.Handler) {
-	if err := http.Serve(listener, handler); err != nil && !isClosedListenerError(err) {
-		errors.LogErrorInner(context.Background(), err, "failed to start metrics server")
-	}
-}
-
-func isClosedListenerError(err error) bool {
-	if err == nil {
-		return true
-	}
-	if stderrors.Is(err, stdnet.ErrClosed) || stderrors.Is(err, http.ErrServerClosed) {
-		return true
-	}
-	errText := err.Error()
-	return strings.Contains(errText, "listen closed") ||
-		strings.Contains(errText, "use of closed network connection")
-}
-
-func (p *MetricsHandler) httpHandler() http.Handler {
-	mux := http.NewServeMux()
-	mux.HandleFunc("/debug/vars", p.handleDebugVars)
-	mux.HandleFunc("/debug/pprof/", pprof.Index)
-	mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
-	mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
-	mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
-	mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
-	return mux
-}
-
-func (p *MetricsHandler) handleDebugVars(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	vars := map[string]json.RawMessage{}
-	expvar.Do(func(kv expvar.KeyValue) {
-		value := json.RawMessage(kv.Value.String())
-		if !json.Valid(value) {
-			value = json.RawMessage("null")
-		}
-		vars[kv.Key] = value
-	})
-	vars["stats"] = marshalJSON(p.stats())
-	vars["observatory"] = marshalJSON(p.observatoryStatus())
-
-	payload, err := json.Marshal(vars)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	w.Write(payload)
-}
-
-func marshalJSON(value interface{}) json.RawMessage {
-	data, err := json.Marshal(value)
-	if err != nil {
-		return json.RawMessage("null")
-	}
-	return data
-}
-
-func (p *MetricsHandler) stats() map[string]map[string]map[string]int64 {
-	resp := map[string]map[string]map[string]int64{
-		"inbound":  {},
-		"outbound": {},
-		"user":     {},
-	}
-	p.statsManager.VisitCounters(func(name string, counter feature_stats.Counter) bool {
-		nameSplit := strings.Split(name, ">>>")
-		if len(nameSplit) < 4 {
-			return true
-		}
-		typeName, tagOrUser, direction := nameSplit[0], nameSplit[1], nameSplit[3]
-		items, found := resp[typeName]
-		if !found {
-			items = map[string]map[string]int64{}
-			resp[typeName] = items
-		}
-		if item, found := items[tagOrUser]; found {
-			item[direction] = counter.Value()
-		} else {
-			items[tagOrUser] = map[string]int64{
-				direction: counter.Value(),
-			}
-		}
-		return true
-	})
-	return resp
-}
-
-func (p *MetricsHandler) observatoryStatus() interface{} {
-	feature := core.MustFromContext(p.ctx).GetFeature(extension.ObservatoryType())
-	if feature == nil {
-		return nil
-	}
-	observatoryFeature := feature.(extension.Observatory)
-	resp := map[string]*observatory.OutboundStatus{}
-	if o, err := observatoryFeature.GetObservation(context.Background()); err != nil {
-		return err
-	} else {
-		for _, x := range o.(*observatory.ObservationResult).GetStatus() {
-			resp[x.OutboundTag] = x
-		}
-	}
-	return resp
+	return nil
 }

 func init() {
@@ -1,161 +0,0 @@
-package metrics
-
-import (
-	"context"
-	"encoding/json"
-	stdnet "net"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/xtls/xray-core/app/dispatcher"
-	"github.com/xtls/xray-core/app/proxyman"
-	_ "github.com/xtls/xray-core/app/proxyman/inbound"
-	_ "github.com/xtls/xray-core/app/proxyman/outbound"
-	appstats "github.com/xtls/xray-core/app/stats"
-	"github.com/xtls/xray-core/common/serial"
-	"github.com/xtls/xray-core/core"
-	feature_outbound "github.com/xtls/xray-core/features/outbound"
-)
-
-func TestMetricsCanRestartInSameProcess(t *testing.T) {
-	for i := 0; i < 2; i++ {
-		server := startMetricsTestServer(t)
-		readMetricsVars(t, server)
-		readMetricsPprof(t, server)
-		if err := server.Close(); err != nil {
-			t.Fatalf("failed to close metrics server: %v", err)
-		}
-	}
-}
-
-func TestMetricsCanRunMultipleInstancesInSameProcess(t *testing.T) {
-	server1 := startMetricsTestServer(t)
-	t.Cleanup(func() {
-		_ = server1.Close()
-	})
-	server2 := startMetricsTestServer(t)
-	t.Cleanup(func() {
-		_ = server2.Close()
-	})
-
-	readMetricsVars(t, server1)
-	readMetricsVars(t, server2)
-}
-
-func TestMetricsListenOnlyWithoutTagDoesNotRegisterOutbound(t *testing.T) {
-	listen := pickMetricsListenAddress(t)
-	server := startMetricsTestServerWithMetricsConfig(t, &Config{
-		Listen: listen,
-	})
-	t.Cleanup(func() {
-		_ = server.Close()
-	})
-
-	response, err := http.Get("http://" + listen + "/debug/vars")
-	if err != nil {
-		t.Fatalf("failed to read listen-only metrics: %v", err)
-	}
-	defer response.Body.Close()
-	if response.StatusCode != http.StatusOK {
-		t.Fatalf("unexpected listen-only metrics status: %d", response.StatusCode)
-	}
-
-	outboundManager := server.GetFeature(feature_outbound.ManagerType()).(feature_outbound.Manager)
-	if handlers := outboundManager.ListHandlers(context.Background()); len(handlers) != 0 {
-		t.Fatalf("listen-only metrics registered outbound handlers: got %d, want 0", len(handlers))
-	}
-}
-
-func startMetricsTestServer(t *testing.T) *core.Instance {
-	return startMetricsTestServerWithMetricsConfig(t, &Config{
-		Tag: "metrics_out",
-	})
-}
-
-func startMetricsTestServerWithMetricsConfig(t *testing.T, metricsConfig *Config) *core.Instance {
-	t.Helper()
-
-	server, err := core.New(metricsTestConfig(metricsConfig))
-	if err != nil {
-		t.Fatalf("failed to create metrics server: %v", err)
-	}
-	if err := server.Start(); err != nil {
-		_ = server.Close()
-		t.Fatalf("failed to start metrics server: %v", err)
-	}
-	return server
-}
-
-func metricsTestConfig(metricsConfig *Config) *core.Config {
-	return &core.Config{
-		App: []*serial.TypedMessage{
-			serial.ToTypedMessage(&dispatcher.Config{}),
-			serial.ToTypedMessage(&proxyman.InboundConfig{}),
-			serial.ToTypedMessage(&proxyman.OutboundConfig{}),
-			serial.ToTypedMessage(&appstats.Config{}),
-			serial.ToTypedMessage(metricsConfig),
-		},
-	}
-}
-
-func pickMetricsListenAddress(t *testing.T) string {
-	t.Helper()
-
-	listener, err := stdnet.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("failed to pick metrics listen address: %v", err)
-	}
-	defer listener.Close()
-	return listener.Addr().String()
-}
-
-func readMetricsVars(t *testing.T, server *core.Instance) {
-	t.Helper()
-
-	recorder := httptest.NewRecorder()
-	metricsHandler(t, server).httpHandler().ServeHTTP(
-		recorder,
-		httptest.NewRequest(http.MethodGet, "/debug/vars", nil),
-	)
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("unexpected metrics vars status: %d", recorder.Code)
-	}
-
-	var payload map[string]interface{}
-	if err := json.NewDecoder(recorder.Body).Decode(&payload); err != nil {
-		t.Fatalf("failed to decode metrics vars: %v", err)
-	}
-	if _, found := payload["stats"]; !found {
-		t.Fatal("metrics vars missing stats")
-	}
-	if _, found := payload["observatory"]; !found {
-		t.Fatal("metrics vars missing observatory")
-	}
-}
-
-func readMetricsPprof(t *testing.T, server *core.Instance) {
-	t.Helper()
-
-	recorder := httptest.NewRecorder()
-	metricsHandler(t, server).httpHandler().ServeHTTP(
-		recorder,
-		httptest.NewRequest(http.MethodGet, "/debug/pprof/goroutine?debug=1", nil),
-	)
-
-	if recorder.Code != http.StatusOK {
-		t.Fatalf("unexpected metrics pprof status: %d", recorder.Code)
-	}
-}
-
-func metricsHandler(t *testing.T, server *core.Instance) *MetricsHandler {
-	t.Helper()
-
-	feature := server.GetFeature((*MetricsHandler)(nil))
-	handler, ok := feature.(*MetricsHandler)
-	if !ok || handler == nil {
-		t.Fatal("metrics handler not registered")
-	}
-	return handler
-}
@@ -2,6 +2,7 @@ package burst

 import (
 	"context"
+
 	"sync"

 	"github.com/xtls/xray-core/app/observatory"
@@ -71,6 +72,7 @@ func (o *Observer) Start() error {
 		o.hp.StartScheduler(func() ([]string, error) {
 			hs, ok := o.ohm.(outbound.HandlerSelector)
 			if !ok {
+
 				return nil, errors.New("outbound.Manager is not a HandlerSelector")
 			}

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"

 	"github.com/xtls/xray-core/common/dice"
@@ -25,12 +24,11 @@ type HealthPingSettings struct {

 // HealthPing is the health checker for balancers
 type HealthPing struct {
-	ctx           context.Context
-	cancelCtx     context.CancelFunc
-	cancelPending atomic.Pointer[context.CancelFunc]
-	dispatcher    routing.Dispatcher
-	access        sync.Mutex
-	ticker        *time.Ticker
+	ctx         context.Context
+	dispatcher  routing.Dispatcher
+	access      sync.Mutex
+	ticker      *time.Ticker
+	tickerClose chan struct{}

 	Settings *HealthPingSettings
 	Results  map[string]*HealthPingRTTS
@@ -64,10 +62,10 @@ func NewHealthPing(ctx context.Context, dispatcher routing.Dispatcher, config *H
 		settings.Destination = "https://connectivitycheck.gstatic.com/generate_204"
 	}
 	if settings.Interval == 0 {
-		settings.Interval = 1 * time.Minute
-	} else if settings.Interval < 10*time.Second {
+		settings.Interval = time.Duration(1) * time.Minute
+	} else if settings.Interval < 10 {
 		errors.LogWarning(ctx, "health check interval is too small, 10s is applied")
-		settings.Interval = 10 * time.Second
+		settings.Interval = time.Duration(10) * time.Second
 	}
 	if settings.SamplingCount <= 0 {
 		settings.SamplingCount = 10
@@ -75,12 +73,10 @@ func NewHealthPing(ctx context.Context, dispatcher routing.Dispatcher, config *H
 	if settings.Timeout <= 0 {
 		// results are saved after all health pings finish,
 		// a larger timeout could possibly makes checks run longer
-		settings.Timeout = 5 * time.Second
+		settings.Timeout = time.Duration(5) * time.Second
 	}
-	ctx, cancel := context.WithCancel(ctx)
 	return &HealthPing{
 		ctx:        ctx,
-		cancelCtx:  cancel,
 		dispatcher: dispatcher,
 		Settings:   settings,
 		Results:    nil,
@@ -94,9 +90,9 @@ func (h *HealthPing) StartScheduler(selector func() ([]string, error)) {
 	}
 	interval := h.Settings.Interval * time.Duration(h.Settings.SamplingCount)
 	ticker := time.NewTicker(interval)
+	tickerClose := make(chan struct{})
 	h.ticker = ticker
-
-	// init run to get a fast check result
+	h.tickerClose = tickerClose
 	go func() {
 		tags, err := selector()
 		if err != nil {
@@ -114,20 +110,13 @@ func (h *HealthPing) StartScheduler(selector func() ([]string, error)) {
 					errors.LogWarning(h.ctx, "error select outbounds for scheduled health check: ", err)
 					return
 				}
-				subCtx, cancel := context.WithCancel(h.ctx)
-				old := h.cancelPending.Swap(&cancel)
-				if old != nil {
-					errors.LogDebug(h.ctx, "scheduled health check not finished before next round, canceling previous one")
-					(*old)()
-				}
-				h.doCheck(subCtx, tags, interval, h.Settings.SamplingCount)
-				h.cancelPending.CompareAndSwap(&cancel, nil)
+				h.doCheck(tags, interval, h.Settings.SamplingCount)
 				h.Cleanup(tags)
 			}()
 			select {
 			case <-ticker.C:
 				continue
-			case <-h.ctx.Done():
+			case <-tickerClose:
 				return
 			}
 		}
@@ -141,7 +130,8 @@ func (h *HealthPing) StopScheduler() {
 	}
 	h.ticker.Stop()
 	h.ticker = nil
-	h.cancelCtx()
+	close(h.tickerClose)
+	h.tickerClose = nil
 }

 // Check implements the HealthChecker
@@ -150,7 +140,7 @@ func (h *HealthPing) Check(tags []string) error {
 		return nil
 	}
 	errors.LogInfo(h.ctx, "perform one-time health check for tags ", tags)
-	h.doCheck(h.ctx, tags, 0, 1)
+	h.doCheck(tags, 0, 1)
 	return nil
 }

@@ -161,14 +151,13 @@ type rtt struct {

 // doCheck performs the 'rounds' amount checks in given 'duration'. You should make
 // sure all tags are valid for current balancer
-// cancel ctx will stop all pending checks
-func (h *HealthPing) doCheck(ctx context.Context, tags []string, duration time.Duration, rounds int) {
+func (h *HealthPing) doCheck(tags []string, duration time.Duration, rounds int) {
 	count := len(tags) * rounds
 	if count == 0 {
 		return
 	}
 	ch := make(chan *rtt, count)
-	timers := make([]*time.Timer, 0, count)
+
 	for _, tag := range tags {
 		handler := tag
 		client := newPingClient(
@@ -183,7 +172,7 @@ func (h *HealthPing) doCheck(ctx context.Context, tags []string, duration time.D
 			if duration > 0 {
 				delay = time.Duration(dice.RollInt63n(int64(duration)))
 			}
-			timers = append(timers, time.AfterFunc(delay, func() {
+			time.AfterFunc(delay, func() {
 				errors.LogDebug(h.ctx, "checking ", handler)
 				delay, err := client.MeasureDelay(h.Settings.HttpMethod)
 				if err == nil {
@@ -211,21 +200,14 @@ func (h *HealthPing) doCheck(ctx context.Context, tags []string, duration time.D
 					handler: handler,
 					value:   rttFailed,
 				}
-			}))
+			})
 		}
 	}
 	for i := 0; i < count; i++ {
-		select {
-		case rtt := <-ch:
-			if rtt.value > 0 {
-				// should not put results when network is down
-				h.PutResult(rtt.handler, rtt.value)
-			}
-		case <-ctx.Done():
-			for _, timer := range timers {
-				timer.Stop()
-			}
-			return
+		rtt := <-ch
+		if rtt.value > 0 {
+			// should not put results when network is down
+			h.PutResult(rtt.handler, rtt.value)
 		}
 	}
 }
@@ -59,7 +59,7 @@ func (h *HealthPingRTTS) Put(d time.Duration) {
 	if h.rtts == nil {
 		h.rtts = make([]*pingRTT, h.cap)
 		for i := 0; i < h.cap; i++ {
-			h.rtts[i] = &pingRTT{value: rttUntested}
+			h.rtts[i] = &pingRTT{}
 		}
 		h.idx = -1
 	}
@@ -88,7 +88,7 @@ func (h *HealthPingRTTS) getStatistics() *HealthPingStats {
 	validRTTs := make([]time.Duration, 0)
 	for _, rtt := range h.rtts {
 		switch {
-		case rtt.value == rttUntested || time.Since(rtt.time) > h.validity:
+		case rtt.value == 0 || time.Since(rtt.time) > h.validity:
 			continue
 		case rtt.value == rttFailed:
 			stats.Fail++
@@ -78,12 +78,6 @@ func (o *Observer) background() {
 			sleepTime = time.Duration(o.config.ProbeInterval)
 		}

-		if len(outbounds) == 0 {
-			errors.LogWarning(o.ctx, "no outbound matches subjectSelector ", o.config.SubjectSelector)
-			time.Sleep(sleepTime)
-			continue
-		}
-
 		if !o.config.EnableConcurrency {
 			sort.Strings(outbounds)
 			for _, v := range outbounds {
@@ -192,7 +186,7 @@ func (o *Observer) probe(outbound string) ProbeResult {
 		return nil
 	})
 	if err != nil {
-		errorMessage := "the outbound " + outbound + " is dead: GET request failed:" + err.Error() + "with outbound handler report underlying connection failed"
+		var errorMessage = "the outbound " + outbound + " is dead: GET request failed:" + err.Error() + "with outbound handler report underlying connection failed"
 		errors.LogInfoInner(o.ctx, errorCollectorForRequest.UnderlyingError(), errorMessage)
 		return ProbeResult{Alive: false, LastErrorReason: errorMessage}
 	}
@@ -138,7 +138,7 @@ func (s *handlerServer) GetInboundUsers(ctx context.Context, request *GetInbound
 	if len(request.Email) > 0 {
 		return &GetInboundUserResponse{Users: []*protocol.User{protocol.ToProtoUser(um.GetUser(ctx, request.Email))}}, nil
 	}
-	result := make([]*protocol.User, 0, 100)
+	var result = make([]*protocol.User, 0, 100)
 	users := um.GetUsers(ctx)
 	for _, u := range users {
 		result = append(result, protocol.ToProtoUser(u))
@@ -330,6 +330,7 @@ type SenderConfig struct {
 	// Send traffic through the given IP. Only IP is allowed.
 	Via               *net.IPOrDomain         `protobuf:"bytes,1,opt,name=via,proto3" json:"via,omitempty"`
 	StreamSettings    *internet.StreamConfig  `protobuf:"bytes,2,opt,name=stream_settings,json=streamSettings,proto3" json:"stream_settings,omitempty"`
+	ProxySettings     *internet.ProxyConfig   `protobuf:"bytes,3,opt,name=proxy_settings,json=proxySettings,proto3" json:"proxy_settings,omitempty"`
 	MultiplexSettings *MultiplexingConfig     `protobuf:"bytes,4,opt,name=multiplex_settings,json=multiplexSettings,proto3" json:"multiplex_settings,omitempty"`
 	ViaCidr           string                  `protobuf:"bytes,5,opt,name=via_cidr,json=viaCidr,proto3" json:"via_cidr,omitempty"`
 	TargetStrategy    internet.DomainStrategy `protobuf:"varint,6,opt,name=target_strategy,json=targetStrategy,proto3,enum=xray.transport.internet.DomainStrategy" json:"target_strategy,omitempty"`
@@ -381,6 +382,13 @@ func (x *SenderConfig) GetStreamSettings() *internet.StreamConfig {
 	return nil
 }

+func (x *SenderConfig) GetProxySettings() *internet.ProxyConfig {
+	if x != nil {
+		return x.ProxySettings
+	}
+	return nil
+}
+
 func (x *SenderConfig) GetMultiplexSettings() *MultiplexingConfig {
 	if x != nil {
 		return x.MultiplexSettings
@@ -498,13 +506,14 @@ const file_app_proxyman_config_proto_rawDesc = "" +
 	"\x03tag\x18\x01 \x01(\tR\x03tag\x12M\n" +
 	"\x11receiver_settings\x18\x02 \x01(\v2 .xray.common.serial.TypedMessageR\x10receiverSettings\x12G\n" +
 	"\x0eproxy_settings\x18\x03 \x01(\v2 .xray.common.serial.TypedMessageR\rproxySettings\"\x10\n" +
-	"\x0eOutboundConfig\"\xd6\x02\n" +
+	"\x0eOutboundConfig\"\x9d\x03\n" +
 	"\fSenderConfig\x12-\n" +
 	"\x03via\x18\x01 \x01(\v2\x1b.xray.common.net.IPOrDomainR\x03via\x12N\n" +
-	"\x0fstream_settings\x18\x02 \x01(\v2%.xray.transport.internet.StreamConfigR\x0estreamSettings\x12T\n" +
+	"\x0fstream_settings\x18\x02 \x01(\v2%.xray.transport.internet.StreamConfigR\x0estreamSettings\x12K\n" +
+	"\x0eproxy_settings\x18\x03 \x01(\v2$.xray.transport.internet.ProxyConfigR\rproxySettings\x12T\n" +
 	"\x12multiplex_settings\x18\x04 \x01(\v2%.xray.app.proxyman.MultiplexingConfigR\x11multiplexSettings\x12\x19\n" +
 	"\bvia_cidr\x18\x05 \x01(\tR\aviaCidr\x12P\n" +
-	"\x0ftarget_strategy\x18\x06 \x01(\x0e2'.xray.transport.internet.DomainStrategyR\x0etargetStrategyJ\x04\b\x03\x10\x04\"\xa4\x01\n" +
+	"\x0ftarget_strategy\x18\x06 \x01(\x0e2'.xray.transport.internet.DomainStrategyR\x0etargetStrategy\"\xa4\x01\n" +
 	"\x12MultiplexingConfig\x12\x18\n" +
 	"\aenabled\x18\x01 \x01(\bR\aenabled\x12 \n" +
 	"\vconcurrency\x18\x02 \x01(\x05R\vconcurrency\x12(\n" +
@@ -539,7 +548,8 @@ var file_app_proxyman_config_proto_goTypes = []any{
 	(*net.IPOrDomain)(nil),        // 10: xray.common.net.IPOrDomain
 	(*internet.StreamConfig)(nil), // 11: xray.transport.internet.StreamConfig
 	(*serial.TypedMessage)(nil),   // 12: xray.common.serial.TypedMessage
-	(internet.DomainStrategy)(0),  // 13: xray.transport.internet.DomainStrategy
+	(*internet.ProxyConfig)(nil),  // 13: xray.transport.internet.ProxyConfig
+	(internet.DomainStrategy)(0),  // 14: xray.transport.internet.DomainStrategy
 }
 var file_app_proxyman_config_proto_depIdxs = []int32{
 	7,  // 0: xray.app.proxyman.SniffingConfig.domains_excluded:type_name -> xray.common.geodata.DomainRule
@@ -552,13 +562,14 @@ var file_app_proxyman_config_proto_depIdxs = []int32{
 	12, // 7: xray.app.proxyman.InboundHandlerConfig.proxy_settings:type_name -> xray.common.serial.TypedMessage
 	10, // 8: xray.app.proxyman.SenderConfig.via:type_name -> xray.common.net.IPOrDomain
 	11, // 9: xray.app.proxyman.SenderConfig.stream_settings:type_name -> xray.transport.internet.StreamConfig
-	6,  // 10: xray.app.proxyman.SenderConfig.multiplex_settings:type_name -> xray.app.proxyman.MultiplexingConfig
-	13, // 11: xray.app.proxyman.SenderConfig.target_strategy:type_name -> xray.transport.internet.DomainStrategy
-	12, // [12:12] is the sub-list for method output_type
-	12, // [12:12] is the sub-list for method input_type
-	12, // [12:12] is the sub-list for extension type_name
-	12, // [12:12] is the sub-list for extension extendee
-	0,  // [0:12] is the sub-list for field type_name
+	13, // 10: xray.app.proxyman.SenderConfig.proxy_settings:type_name -> xray.transport.internet.ProxyConfig
+	6,  // 11: xray.app.proxyman.SenderConfig.multiplex_settings:type_name -> xray.app.proxyman.MultiplexingConfig
+	14, // 12: xray.app.proxyman.SenderConfig.target_strategy:type_name -> xray.transport.internet.DomainStrategy
+	13, // [13:13] is the sub-list for method output_type
+	13, // [13:13] is the sub-list for method input_type
+	13, // [13:13] is the sub-list for extension type_name
+	13, // [13:13] is the sub-list for extension extendee
+	0,  // [0:13] is the sub-list for field type_name
 }

 func init() { file_app_proxyman_config_proto_init() }
@@ -57,7 +57,7 @@ message SenderConfig {
  // Send traffic through the given IP. Only IP is allowed.
  xray.common.net.IPOrDomain via = 1;
  xray.transport.internet.StreamConfig stream_settings = 2;
-  reserved 3;
+  xray.transport.internet.ProxyConfig proxy_settings = 3;
  MultiplexingConfig multiplex_settings = 4;
  string via_cidr = 5;
  xray.transport.internet.DomainStrategy target_strategy = 6;
@@ -26,7 +26,7 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 	if len(tag) > 0 && policy.ForSystem().Stats.InboundUplink {
 		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "inbound>>>" + tag + ">>>traffic>>>uplink"
-		c, _ := statsManager.GetOrRegisterCounter(name)
+		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {
 			uplinkCounter = c
 		}
@@ -34,7 +34,7 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 	if len(tag) > 0 && policy.ForSystem().Stats.InboundDownlink {
 		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "inbound>>>" + tag + ">>>traffic>>>downlink"
-		c, _ := statsManager.GetOrRegisterCounter(name)
+		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {
 			downlinkCounter = c
 		}
@@ -57,23 +57,16 @@ func NewAlwaysOnInboundHandler(ctx context.Context, tag string, receiverConfig *
 	if err != nil {
 		return nil, err
 	}
-	src := net.TCPDestination(net.AnyIP, 0)
-	if receiverConfig.Listen != nil {
-		src.Address = receiverConfig.Listen.AsAddress()
-	}
-	if receiverConfig.PortList != nil && len(receiverConfig.PortList.Range) > 0 {
-		src.Port = net.Port(receiverConfig.PortList.Range[0].From)
-	}
-	mss, err := internet.ToMemoryStreamConfig(receiverConfig.StreamSettings)
-	if err != nil {
-		return nil, errors.New("failed to parse stream config").Base(err).AtWarning()
-	}

-	newCtx := session.ContextWithInbound(ctx, &session.Inbound{Tag: tag, Source: src})
-	newCtx = session.ContextWithContent(newCtx, &session.Content{SniffingRequest: sniffingRequest})
-	newCtx = session.ContextWithStreamSettings(newCtx, mss)
-
-	rawProxy, err := common.CreateObject(newCtx, proxyConfig)
+	// Set tag and sniffing config in context before creating proxy
+	// This allows proxies like TUN to access these settings
+	ctx = session.ContextWithInbound(ctx, &session.Inbound{Tag: tag})
+	if receiverConfig.SniffingSettings != nil {
+		ctx = session.ContextWithContent(ctx, &session.Content{
+			SniffingRequest: sniffingRequest,
+		})
+	}
+	rawProxy, err := common.CreateObject(ctx, proxyConfig)
 	if err != nil {
 		return nil, err
 	}
@@ -99,6 +92,11 @@ func NewAlwaysOnInboundHandler(ctx context.Context, tag string, receiverConfig *
 		address = net.AnyIP
 	}

+	mss, err := internet.ToMemoryStreamConfig(receiverConfig.StreamSettings)
+	if err != nil {
+		return nil, errors.New("failed to parse stream config").Base(err).AtWarning()
+	}
+
 	if receiverConfig.ReceiveOriginalDestination {
 		if mss.SocketSettings == nil {
 			mss.SocketSettings = &internet.SocketConfig{}
@@ -172,12 +170,6 @@ func NewAlwaysOnInboundHandler(ctx context.Context, tag string, receiverConfig *

 // Start implements common.Runnable.
 func (h *AlwaysOnInboundHandler) Start() error {
-	// for inbound without worker (TUN)
-	if run, ok := h.proxy.(common.Runnable); ok {
-		if err := run.Start(); err != nil {
-			return errors.New("failed to start proxy").Base(err)
-		}
-	}
 	for _, worker := range h.workers {
 		if err := worker.Start(); err != nil {
 			return err
@@ -16,10 +16,10 @@ import (

 // Manager manages all inbound handlers.
 type Manager struct {
-	access           sync.RWMutex
+	access          sync.RWMutex
 	untaggedHandlers []inbound.Handler
-	taggedHandlers   map[string]inbound.Handler
-	running          bool
+	taggedHandlers  map[string]inbound.Handler
+	running         bool
 }

 // New returns a new Manager for inbound handlers.
@@ -18,9 +18,9 @@ import (
 	"github.com/xtls/xray-core/features/routing"
 	"github.com/xtls/xray-core/features/stats"
 	"github.com/xtls/xray-core/proxy"
-	hysteria_proxy "github.com/xtls/xray-core/proxy/hysteria"
+	"github.com/xtls/xray-core/proxy/hysteria/account"
+	hyCtx "github.com/xtls/xray-core/proxy/hysteria/ctx"
 	"github.com/xtls/xray-core/transport/internet"
-	"github.com/xtls/xray-core/transport/internet/hysteria"
 	"github.com/xtls/xray-core/transport/internet/stat"
 	"github.com/xtls/xray-core/transport/internet/tcp"
 	"github.com/xtls/xray-core/transport/internet/udp"
@@ -134,8 +134,10 @@ func (w *tcpWorker) Proxy() proxy.Inbound {
 func (w *tcpWorker) Start() error {
 	ctx := context.Background()

-	if v, ok := w.proxy.(*hysteria_proxy.Server); ok {
-		ctx = hysteria.ContextWithValidator(ctx, v.HysteriaInboundValidator())
+	type HysteriaInboundValidator interface{ HysteriaInboundValidator() *account.Validator }
+	if v, ok := w.proxy.(HysteriaInboundValidator); ok {
+		ctx = hyCtx.ContextWithRequireDatagram(ctx, true)
+		ctx = hyCtx.ContextWithValidator(ctx, v.HysteriaInboundValidator())
 	}

 	hub, err := internet.ListenTCP(ctx, w.address, w.port, w.stream, func(conn stat.Connection) {
@@ -6,6 +6,7 @@ import (
 	goerrors "errors"
 	"io"
 	"math/big"
+	"os"

 	"github.com/xtls/xray-core/common/dice"

@@ -15,6 +16,7 @@ import (
 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/mux"
 	"github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/common/net/cnc"
 	"github.com/xtls/xray-core/common/serial"
 	"github.com/xtls/xray-core/common/session"
 	"github.com/xtls/xray-core/core"
@@ -25,6 +27,8 @@ import (
 	"github.com/xtls/xray-core/transport"
 	"github.com/xtls/xray-core/transport/internet"
 	"github.com/xtls/xray-core/transport/internet/stat"
+	"github.com/xtls/xray-core/transport/internet/tls"
+	"github.com/xtls/xray-core/transport/pipe"
 	"google.golang.org/protobuf/proto"
 )

@@ -36,7 +40,7 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 	if len(tag) > 0 && policy.ForSystem().Stats.OutboundUplink {
 		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "outbound>>>" + tag + ">>>traffic>>>uplink"
-		c, _ := statsManager.GetOrRegisterCounter(name)
+		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {
 			uplinkCounter = c
 		}
@@ -44,7 +48,7 @@ func getStatCounter(v *core.Instance, tag string) (stats.Counter, stats.Counter)
 	if len(tag) > 0 && policy.ForSystem().Stats.OutboundDownlink {
 		statsManager := v.GetFeature(stats.ManagerType()).(stats.Manager)
 		name := "outbound>>>" + tag + ">>>traffic>>>downlink"
-		c, _ := statsManager.GetOrRegisterCounter(name)
+		c, _ := stats.GetOrRegisterCounter(statsManager, name)
 		if c != nil {
 			downlinkCounter = c
 		}
@@ -60,6 +64,7 @@ type Handler struct {
 	streamSettings  *internet.MemoryStreamConfig
 	proxyConfig     proto.Message
 	proxy           proxy.Outbound
+	outboundManager outbound.Manager
 	mux             *mux.ClientManager
 	xudp            *mux.ClientManager
 	udp443          string
@@ -73,6 +78,7 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou
 	uplinkCounter, downlinkCounter := getStatCounter(v, config.Tag)
 	h := &Handler{
 		tag:             config.Tag,
+		outboundManager: v.GetFeature(outbound.ManagerType()).(outbound.Manager),
 		uplinkCounter:   uplinkCounter,
 		downlinkCounter: downlinkCounter,
 	}
@@ -103,10 +109,6 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou

 	ctx = session.ContextWithFullHandler(ctx, h)

-	if h.streamSettings != nil {
-		ctx = session.ContextWithStreamSettings(ctx, h.streamSettings)
-	}
-
 	rawProxyHandler, err := common.CreateObject(ctx, proxyConfig)
 	if err != nil {
 		return nil, err
@@ -194,6 +196,7 @@ func (h *Handler) Dispatch(ctx context.Context, link *transport.Link) {
 				common.Interrupt(link.Reader)
 				return
 			}
+
 		} else {
 			unchangedDomain := ob.Target.Address.Domain()
 			ob.Target.Address = net.IPAddress(ips[dice.Roll(len(ips))])
@@ -266,26 +269,71 @@ func (h *Handler) DestIpAddress() net.IP {

 // Dial implements internet.Dialer.
 func (h *Handler) Dial(ctx context.Context, dest net.Destination) (stat.Connection, error) {
-	if h.senderSettings != nil && h.senderSettings.Via != nil {
-		outbounds := session.OutboundsFromContext(ctx)
-		ob := outbounds[len(outbounds)-1]
-		h.SetOutboundGateway(ctx, ob)
+	if h.senderSettings != nil {
+
+		if h.senderSettings.ProxySettings.HasTag() {
+
+			tag := h.senderSettings.ProxySettings.Tag
+			handler := h.outboundManager.GetHandler(tag)
+			if handler != nil {
+				errors.LogDebug(ctx, "proxying to ", tag, " for dest ", dest)
+				outbounds := session.OutboundsFromContext(ctx)
+				ctx = session.ContextWithOutbounds(ctx, append(outbounds, &session.Outbound{
+					Target: dest,
+					Tag:    tag,
+				})) // add another outbound in session ctx
+				opts := pipe.OptionsFromContext(ctx)
+				uplinkReader, uplinkWriter := pipe.New(opts...)
+				downlinkReader, downlinkWriter := pipe.New(opts...)
+
+				go handler.Dispatch(ctx, &transport.Link{Reader: uplinkReader, Writer: downlinkWriter})
+				conn := cnc.NewConnection(cnc.ConnectionInputMulti(uplinkWriter), cnc.ConnectionOutputMulti(downlinkReader))
+
+				if config := tls.ConfigFromStreamSettings(h.streamSettings); config != nil {
+					tlsConfig := config.GetTLSConfig(tls.WithDestination(dest))
+					conn = tls.Client(conn, tlsConfig)
+				}
+
+				return h.getStatCouterConnection(conn), nil
+			}
+
+			errors.LogError(ctx, "failed to get outbound handler with tag: ", tag)
+			return nil, errors.New("failed to get outbound handler with tag: " + tag)
+		}
+
+		if h.senderSettings.Via != nil {
+			outbounds := session.OutboundsFromContext(ctx)
+			ob := outbounds[len(outbounds)-1]
+			h.SetOutboundGateway(ctx, ob)
+		}
+
+	}
+
+	if conn, err := h.getUoTConnection(ctx, dest); err != os.ErrInvalid {
+		return conn, err
 	}

 	conn, err := internet.Dial(ctx, dest, h.streamSettings)
 	conn = h.getStatCouterConnection(conn)
+	outbounds := session.OutboundsFromContext(ctx)
+	if outbounds != nil {
+		ob := outbounds[len(outbounds)-1]
+		ob.Conn = conn
+	} else {
+		// for Vision's pre-connect
+	}
 	return conn, err
 }

 func (h *Handler) SetOutboundGateway(ctx context.Context, ob *session.Outbound) {
-	if ob.Gateway == nil && h.senderSettings != nil && h.senderSettings.Via != nil &&
-		(h.streamSettings.SocketSettings == nil || len(h.streamSettings.SocketSettings.DialerProxy) == 0) {
+	if ob.Gateway == nil && h.senderSettings != nil && h.senderSettings.Via != nil && !h.senderSettings.ProxySettings.HasTag() && (h.streamSettings.SocketSettings == nil || len(h.streamSettings.SocketSettings.DialerProxy) == 0) {
 		var domain string
 		addr := h.senderSettings.Via.AsAddress()
 		domain = h.senderSettings.Via.GetDomain()
 		switch {
 		case h.senderSettings.ViaCidr != "":
 			ob.Gateway = ParseRandomIP(addr, h.senderSettings.ViaCidr)
+
 		case domain == "origin":
 			if inbound := session.InboundFromContext(ctx); inbound != nil {
 				if inbound.Local.IsValid() && inbound.Local.Address.Family().IsIP() {
@@ -300,9 +348,12 @@ func (h *Handler) SetOutboundGateway(ctx context.Context, ob *session.Outbound)
 					errors.LogDebug(ctx, "use inbound source ip as sendthrough: ", inbound.Source.Address.String())
 				}
 			}
-		default: // case addr.Family().IsDomain():
+		//case addr.Family().IsDomain():
+		default:
 			ob.Gateway = addr
+
 		}
+
 	}
 }

@@ -345,6 +396,7 @@ func (h *Handler) ProxySettings() *serial.TypedMessage {
 }

 func ParseRandomIP(addr net.Address, prefix string) net.Address {
+
 	_, ipnet, _ := net.ParseCIDR(addr.IP().String() + "/" + prefix)

 	ones, bits := ipnet.Mask.Size()
@@ -22,8 +22,8 @@ import (
 )

 func TestInterfaces(t *testing.T) {
-	_ = outbound.Handler(new(Handler))
-	_ = outbound.Manager(new(Manager))
+	_ = (outbound.Handler)(new(Handler))
+	_ = (outbound.Manager)(new(Manager))
 }

 const xrayKey core.XrayKey = 1
@@ -43,12 +43,12 @@ func TestOutboundWithoutStatCounter(t *testing.T) {
 	}

 	v, _ := core.New(config)
-	v.AddFeature(outbound.Manager(new(Manager)))
+	v.AddFeature((outbound.Manager)(new(Manager)))
 	ctx := context.WithValue(context.Background(), xrayKey, v)
 	ctx = session.ContextWithOutbounds(ctx, []*session.Outbound{{}})
 	h, _ := NewHandler(ctx, &core.OutboundHandlerConfig{
 		Tag:           "tag",
-		ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}),
+		ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
 	})
 	conn, _ := h.(*Handler).Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146))
 	_, ok := conn.(*stat.CounterConnection)
@@ -73,12 +73,12 @@ func TestOutboundWithStatCounter(t *testing.T) {
 	}

 	v, _ := core.New(config)
-	v.AddFeature(outbound.Manager(new(Manager)))
+	v.AddFeature((outbound.Manager)(new(Manager)))
 	ctx := context.WithValue(context.Background(), xrayKey, v)
 	ctx = session.ContextWithOutbounds(ctx, []*session.Outbound{{}})
 	h, _ := NewHandler(ctx, &core.OutboundHandlerConfig{
 		Tag:           "tag",
-		ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}),
+		ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
 	})
 	conn, _ := h.(*Handler).Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146))
 	_, ok := conn.(*stat.CounterConnection)
@@ -88,6 +88,7 @@ func TestOutboundWithStatCounter(t *testing.T) {
 }

 func TestTagsCache(t *testing.T) {
+
 	test_duration := 10 * time.Second
 	threads_num := 50
 	delay := 10 * time.Millisecond
@@ -117,7 +118,7 @@ func TestTagsCache(t *testing.T) {
 			tag := fmt.Sprintf("%s%d", tags_prefix, idx)
 			cfg := &core.OutboundHandlerConfig{
 				Tag:           tag,
-				ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}),
+				ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
 			}
 			if h, err := NewHandler(ctx, cfg); err == nil {
 				if err := ohm.AddHandler(ctx, h); err == nil {
@@ -162,6 +162,7 @@ func (m *Manager) ListHandlers(ctx context.Context) []outbound.Handler {

 // Select implements outbound.HandlerSelector.
 func (m *Manager) Select(selectors []string) []string {
+
 	key := strings.Join(selectors, ",")
 	if cache, ok := m.tagsCache.Load(key); ok {
 		return cache.([]string)
@@ -0,0 +1,35 @@
+package outbound
+
+import (
+	"context"
+	"os"
+
+	"github.com/sagernet/sing/common/uot"
+	"github.com/xtls/xray-core/common/errors"
+	"github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/transport/internet"
+	"github.com/xtls/xray-core/transport/internet/stat"
+)
+
+func (h *Handler) getUoTConnection(ctx context.Context, dest net.Destination) (stat.Connection, error) {
+	if dest.Address == nil {
+		return nil, errors.New("nil destination address")
+	}
+	if !dest.Address.Family().IsDomain() {
+		return nil, os.ErrInvalid
+	}
+	var uotVersion int
+	if dest.Address.Domain() == uot.MagicAddress {
+		uotVersion = uot.Version
+	} else if dest.Address.Domain() == uot.LegacyMagicAddress {
+		uotVersion = uot.LegacyVersion
+	} else {
+		return nil, os.ErrInvalid
+	}
+	packetConn, err := internet.ListenSystemPacket(ctx, &net.UDPAddr{IP: net.AnyIP.IP(), Port: 0}, h.streamSettings.SocketSettings)
+	if err != nil {
+		return nil, errors.New("unable to listen socket").Base(err)
+	}
+	conn := uot.NewServerConn(packetConn, uotVersion)
+	return h.getStatCouterConnection(conn), nil
+}
@@ -136,7 +136,7 @@ func (b *Balancer) SelectOutbounds() ([]string, error) {

 // GetPrincipleTarget implements routing.BalancerPrincipleTarget
 func (r *Router) GetPrincipleTarget(tag string) ([]string, error) {
-	if b, ok := (*r.balancers.Load())[tag]; ok {
+	if b, ok := r.balancers[tag]; ok {
 		if s, ok := b.strategy.(BalancingPrincipleTarget); ok {
 			candidates, err := b.SelectOutbounds()
 			if err != nil {
@@ -151,7 +151,7 @@ func (r *Router) GetPrincipleTarget(tag string) ([]string, error) {

 // SetOverrideTarget implements routing.BalancerOverrider
 func (r *Router) SetOverrideTarget(tag, target string) error {
-	if b, ok := (*r.balancers.Load())[tag]; ok {
+	if b, ok := r.balancers[tag]; ok {
 		b.override.Put(target)
 		return nil
 	}
@@ -160,7 +160,7 @@ func (r *Router) SetOverrideTarget(tag, target string) error {

 // GetOverrideTarget implements routing.BalancerOverrider
 func (r *Router) GetOverrideTarget(tag string) (string, error) {
-	if b, ok := (*r.balancers.Load())[tag]; ok {
+	if b, ok := r.balancers[tag]; ok {
 		return b.override.Get(), nil
 	}
 	return "", errors.New("cannot find tag")
@@ -2,8 +2,25 @@ package router

 import (
 	sync "sync"
+
+	"github.com/xtls/xray-core/common/errors"
 )

+func (r *Router) OverrideBalancer(balancer string, target string) error {
+	var b *Balancer
+	for tag, bl := range r.balancers {
+		if tag == balancer {
+			b = bl
+			break
+		}
+	}
+	if b == nil {
+		return errors.New("balancer '", balancer, "' not found")
+	}
+	b.override.Put(target)
+	return nil
+}
+
 type overrideSettings struct {
 	target string
 }
@@ -58,6 +58,7 @@ func (s *routingServer) AddRule(ctx context.Context, request *AddRuleRequest) (*
 		return &AddRuleResponse{}, bo.AddRule(request.Config, request.ShouldAppend)
 	}
 	return nil, errors.New("unsupported router implementation")
+
 }

 func (s *routingServer) RemoveRule(ctx context.Context, request *RemoveRuleRequest) (*RemoveRuleResponse, error) {
@@ -5,7 +5,6 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"runtime"
 	"slices"
 	"strings"

@@ -394,22 +393,3 @@ func (m *ProcessNameMatcher) Apply(ctx routing.Context) bool {
 	}
 	return false
 }
-
-// LocalOSMatcher matches the operating system Xray itself is running on. That never
-// changes while Xray is running, so the result is resolved when the rule is built.
-type LocalOSMatcher struct {
-	matched bool
-}
-
-func NewLocalOSMatcher(names []string) *LocalOSMatcher {
-	return &LocalOSMatcher{
-		matched: slices.ContainsFunc(names, func(name string) bool {
-			return strings.EqualFold(name, runtime.GOOS)
-		}),
-	}
-}
-
-// Apply implements Condition.
-func (m *LocalOSMatcher) Apply(_ routing.Context) bool {
-	return m.matched
-}
@@ -2,9 +2,7 @@ package router_test

 import (
 	"path/filepath"
-	"runtime"
 	"strconv"
-	"strings"
 	"testing"

 	. "github.com/xtls/xray-core/app/router"
@@ -345,31 +343,6 @@ func TestChinaSites(t *testing.T) {
 	}
 }

-func TestLocalOSRule(t *testing.T) {
-	otherOS := "plan9"
-	if runtime.GOOS == otherOS {
-		otherOS = "linux"
-	}
-
-	cases := []struct {
-		localOS []string
-		output  bool
-	}{
-		{localOS: []string{runtime.GOOS}, output: true},
-		{localOS: []string{otherOS}, output: false},
-		{localOS: []string{otherOS, runtime.GOOS}, output: true},
-		{localOS: []string{strings.ToUpper(runtime.GOOS)}, output: true},
-	}
-
-	for _, test := range cases {
-		cond, err := (&RoutingRule{LocalOs: test.localOS}).BuildCondition()
-		common.Must(err)
-		if got := cond.Apply(withBackground()); got != test.output {
-			t.Errorf("for localOS %v on %s: expected %v, got %v", test.localOS, runtime.GOOS, test.output, got)
-		}
-	}
-}
-
 func BenchmarkMphDomainMatcher(b *testing.B) {
 	b.Setenv("xray.location.asset", filepath.Join("..", "..", "resources"))
 	rules, err := geodata.ParseDomainRules([]string{"geosite:cn"}, geodata.Domain_Substr)
@@ -33,10 +33,6 @@ func (r *Rule) Apply(ctx routing.Context) bool {
 func (rr *RoutingRule) BuildCondition() (Condition, error) {
 	conds := NewConditionChan()

-	if len(rr.LocalOs) > 0 {
-		conds.Add(NewLocalOSMatcher(rr.LocalOs))
-	}
-
 	if len(rr.InboundTag) > 0 {
 		conds.Add(NewInboundTagMatcher(rr.InboundTag))
 	}
@@ -107,10 +107,8 @@ type RoutingRule struct {
 	VlessRouteList *net.PortList  `protobuf:"bytes,20,opt,name=vless_route_list,json=vlessRouteList,proto3" json:"vless_route_list,omitempty"`
 	Process        []string       `protobuf:"bytes,21,rep,name=process,proto3" json:"process,omitempty"`
 	Webhook        *WebhookConfig `protobuf:"bytes,22,opt,name=webhook,proto3" json:"webhook,omitempty"`
-	// List of operating systems for matching the one Xray itself is running on.
-	LocalOs       []string `protobuf:"bytes,23,rep,name=local_os,json=localOs,proto3" json:"local_os,omitempty"`
-	unknownFields protoimpl.UnknownFields
-	sizeCache     protoimpl.SizeCache
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
 }

 func (x *RoutingRule) Reset() {
@@ -280,13 +278,6 @@ func (x *RoutingRule) GetWebhook() *WebhookConfig {
 	return nil
 }

-func (x *RoutingRule) GetLocalOs() []string {
-	if x != nil {
-		return x.LocalOs
-	}
-	return nil
-}
-
 type isRoutingRule_TargetTag interface {
 	isRoutingRule_TargetTag()
 }
@@ -587,10 +578,8 @@ type Config struct {
 	DomainStrategy Config_DomainStrategy  `protobuf:"varint,1,opt,name=domain_strategy,json=domainStrategy,proto3,enum=xray.app.router.Config_DomainStrategy" json:"domain_strategy,omitempty"`
 	Rule           []*RoutingRule         `protobuf:"bytes,2,rep,name=rule,proto3" json:"rule,omitempty"`
 	BalancingRule  []*BalancingRule       `protobuf:"bytes,3,rep,name=balancing_rule,json=balancingRule,proto3" json:"balancing_rule,omitempty"`
-	// Absolute path to the Lua routing script.
-	Script        string `protobuf:"bytes,4,opt,name=script,proto3" json:"script,omitempty"`
-	unknownFields protoimpl.UnknownFields
-	sizeCache     protoimpl.SizeCache
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
 }

 func (x *Config) Reset() {
@@ -644,18 +633,11 @@ func (x *Config) GetBalancingRule() []*BalancingRule {
 	return nil
 }

-func (x *Config) GetScript() string {
-	if x != nil {
-		return x.Script
-	}
-	return ""
-}
-
 var File_app_router_config_proto protoreflect.FileDescriptor

 const file_app_router_config_proto_rawDesc = "" +
 	"\n" +
-	"\x17app/router/config.proto\x12\x0fxray.app.router\x1a!common/serial/typed_message.proto\x1a\x15common/net/port.proto\x1a\x18common/net/network.proto\x1a\x1bcommon/geodata/geodat.proto\"\xdc\a\n" +
+	"\x17app/router/config.proto\x12\x0fxray.app.router\x1a!common/serial/typed_message.proto\x1a\x15common/net/port.proto\x1a\x18common/net/network.proto\x1a\x1bcommon/geodata/geodat.proto\"\xc1\a\n" +
 	"\vRoutingRule\x12\x12\n" +
 	"\x03tag\x18\x01 \x01(\tH\x00R\x03tag\x12%\n" +
 	"\rbalancing_tag\x18\f \x01(\tH\x00R\fbalancingTag\x12\x19\n" +
@@ -679,8 +661,7 @@ const file_app_router_config_proto_rawDesc = "" +
 	"\x0flocal_port_list\x18\x12 \x01(\v2\x19.xray.common.net.PortListR\rlocalPortList\x12C\n" +
 	"\x10vless_route_list\x18\x14 \x01(\v2\x19.xray.common.net.PortListR\x0evlessRouteList\x12\x18\n" +
 	"\aprocess\x18\x15 \x03(\tR\aprocess\x128\n" +
-	"\awebhook\x18\x16 \x01(\v2\x1e.xray.app.router.WebhookConfigR\awebhook\x12\x19\n" +
-	"\blocal_os\x18\x17 \x03(\tR\alocalOs\x1a=\n" +
+	"\awebhook\x18\x16 \x01(\v2\x1e.xray.app.router.WebhookConfigR\awebhook\x1a=\n" +
 	"\x0fAttributesEntry\x12\x10\n" +
 	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
 	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\f\n" +
@@ -708,12 +689,11 @@ const file_app_router_config_proto_rawDesc = "" +
 	"\tbaselines\x18\x03 \x03(\x03R\tbaselines\x12\x1a\n" +
 	"\bexpected\x18\x04 \x01(\x05R\bexpected\x12\x16\n" +
 	"\x06maxRTT\x18\x05 \x01(\x03R\x06maxRTT\x12\x1c\n" +
-	"\ttolerance\x18\x06 \x01(\x02R\ttolerance\"\xae\x02\n" +
+	"\ttolerance\x18\x06 \x01(\x02R\ttolerance\"\x96\x02\n" +
 	"\x06Config\x12O\n" +
 	"\x0fdomain_strategy\x18\x01 \x01(\x0e2&.xray.app.router.Config.DomainStrategyR\x0edomainStrategy\x120\n" +
 	"\x04rule\x18\x02 \x03(\v2\x1c.xray.app.router.RoutingRuleR\x04rule\x12E\n" +
-	"\x0ebalancing_rule\x18\x03 \x03(\v2\x1e.xray.app.router.BalancingRuleR\rbalancingRule\x12\x16\n" +
-	"\x06script\x18\x04 \x01(\tR\x06script\"B\n" +
+	"\x0ebalancing_rule\x18\x03 \x03(\v2\x1e.xray.app.router.BalancingRuleR\rbalancingRule\"B\n" +
 	"\x0eDomainStrategy\x12\b\n" +
 	"\x04AsIs\x10\x00\x12\x10\n" +
 	"\fIpIfNonMatch\x10\x02\x12\x0e\n" +
@@ -56,9 +56,6 @@ message RoutingRule {

  repeated string process = 21;
  WebhookConfig webhook = 22;
-
-  // List of operating systems for matching the one Xray itself is running on.
-  repeated string local_os = 23;
 }

 message WebhookConfig {
@@ -110,6 +107,4 @@ message Config {
  DomainStrategy domain_strategy = 1;
  repeated RoutingRule rule = 2;
  repeated BalancingRule balancing_rule = 3;
-  // Absolute path to the Lua routing script.
-  string script = 4;
 }
@@ -1,206 +0,0 @@
-package router
-
-import (
-	"context"
-	"runtime"
-
-	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/features/routing"
-	lua "github.com/yuin/gopher-lua"
-)
-
-const (
-	luaContextType    = "xray.router.Context"
-	luaAttributesType = "xray.router.Attributes"
-)
-
-// RegisterLua makes xray.router available to routing scripts.
-func (r *Router) RegisterLua(L *lua.LState) {
-	registerLuaContext(L)
-
-	L.PreloadModule("xray.router", func(L *lua.LState) int {
-		module := L.NewTable()
-
-		module.RawSetString("NetworkUnknown", lua.LNumber(net.Network_Unknown))
-		module.RawSetString("NetworkTCP", lua.LNumber(net.Network_TCP))
-		module.RawSetString("NetworkUDP", lua.LNumber(net.Network_UDP))
-		module.RawSetString("NetworkUNIX", lua.LNumber(net.Network_UNIX))
-		module.RawSetString("LocalOS", lua.LString(runtime.GOOS))
-
-		module.RawSetString("PickOutbound", L.NewFunction(func(L *lua.LState) int {
-			tag, ok := L.Get(2).(lua.LString)
-			if !ok {
-				L.ArgError(2, "balancer tag must be a string")
-				return 0
-			}
-			balancer, found := (*r.balancers.Load())[string(tag)]
-			if !found {
-				L.Push(lua.LNil)
-				pushLuaError(L, errors.New("balancer ", tag, " not found"))
-				return 2
-			}
-			outboundTag, err := balancer.PickOutbound()
-			L.Push(lua.LString(outboundTag))
-			pushLuaError(L, err)
-			return 2
-		}))
-
-		module.RawSetString("FindProcess", L.NewFunction(func(L *lua.LState) int {
-			pid, name, path, err := findProcess(checkLuaContext(L), net.FindProcess)
-			L.Push(lua.LNumber(pid))
-			L.Push(lua.LString(name))
-			L.Push(lua.LString(path))
-			pushLuaError(L, err)
-			return 4
-		}))
-
-		L.Push(module)
-		return 1
-	})
-}
-
-func registerLuaContext(L *lua.LState) {
-	attributes := L.NewTypeMetatable(luaAttributesType)
-	L.SetField(attributes, "__index", L.NewFunction(func(L *lua.LState) int {
-		values := L.CheckUserData(1).Value.(map[string]string)
-		key := L.CheckString(2)
-		if value, found := values[key]; found {
-			L.Push(lua.LString(value))
-		} else {
-			L.Push(lua.LNil)
-		}
-		return 1
-	}))
-	methods := L.NewTable()
-	L.SetFuncs(methods, map[string]lua.LGFunction{
-		"GetSourceIPs": func(L *lua.LState) int {
-			return pushLuaIPs(L, checkLuaContext(L).GetSourceIPs())
-		},
-		"GetTargetIPs": func(L *lua.LState) int {
-			return pushLuaIPs(L, checkLuaContext(L).GetTargetIPs())
-		},
-		"GetLocalIPs": func(L *lua.LState) int {
-			return pushLuaIPs(L, checkLuaContext(L).GetLocalIPs())
-		},
-		"GetAttributes": func(L *lua.LState) int {
-			values := L.NewUserData()
-			values.Value = checkLuaContext(L).GetAttributes()
-			L.SetMetatable(values, attributes)
-			L.Push(values)
-			return 1
-		},
-	})
-	L.SetField(L.NewTypeMetatable(luaContextType), "__index", methods)
-}
-
-func checkLuaContext(L *lua.LState) routing.Context {
-	ctx, ok := L.CheckUserData(1).Value.(routing.Context)
-	if !ok {
-		L.ArgError(1, "routing context expected")
-	}
-	return ctx
-}
-
-func pushLuaIPs(L *lua.LState, ips []net.IP) int {
-	addresses := L.NewUserData()
-	addresses.Value = ips
-	L.Push(addresses)
-	return 1
-}
-
-func pushLuaError(L *lua.LState, err error) {
-	if err == nil {
-		L.Push(lua.LNil)
-		return
-	}
-	value := L.NewUserData()
-	value.Value = err
-	L.Push(value)
-}
-
-// CallLuaHook invokes HandleRoute in the supplied state.
-func (r *Router) CallLuaHook(L *lua.LState, ctx context.Context, routeCtx routing.Context) (string, string, error) {
-	previous, top := L.Context(), L.GetTop()
-	L.SetContext(ctx)
-	defer func() {
-		L.SetTop(top)
-		if previous == nil {
-			L.RemoveContext()
-		} else {
-			L.SetContext(previous)
-		}
-	}()
-	fn := L.GetGlobal("HandleRoute")
-	if fn.Type() != lua.LTFunction {
-		return "", "", errors.New("routing script must define HandleRoute(...)")
-	}
-	value := L.NewUserData()
-	value.Value = routeCtx
-	L.SetMetatable(value, L.GetTypeMetatable(luaContextType))
-	if err := L.CallByParam(lua.P{Fn: fn, NRet: 3, Protect: true},
-		value, lua.LString(routeCtx.GetInboundTag()), lua.LNumber(routeCtx.GetSourcePort()),
-		lua.LNumber(routeCtx.GetTargetPort()), lua.LNumber(routeCtx.GetLocalPort()),
-		lua.LString(routeCtx.GetTargetDomain()), lua.LNumber(routeCtx.GetNetwork()),
-		lua.LString(routeCtx.GetProtocol()), lua.LString(routeCtx.GetUser()),
-		lua.LNumber(routeCtx.GetVlessRoute()), lua.LBool(routeCtx.GetSkipDNSResolve())); err != nil {
-		return "", "", err
-	}
-	return readLuaRouteResult(L.Get(-3), L.Get(-2), L.Get(-1))
-}
-
-func readLuaRouteResult(tagValue, ruleValue, errorValue lua.LValue) (string, string, error) {
-	if errorValue != lua.LNil {
-		if value, ok := errorValue.(*lua.LUserData); ok {
-			if err, ok := value.Value.(error); ok {
-				return "", "", err
-			}
-		}
-		if value, ok := errorValue.(lua.LString); ok {
-			return "", "", errors.New(string(value))
-		}
-		return "", "", errors.New("routing script error must be an error or string")
-	}
-	if tagValue == lua.LNil {
-		return "", "", nil
-	}
-	tag, ok := tagValue.(lua.LString)
-	if !ok {
-		return "", "", errors.New("routing script outboundTag must be a string or nil")
-	}
-	if tag == "" {
-		return "", "", nil
-	}
-	var ruleTag string
-	if ruleValue != lua.LNil {
-		value, ok := ruleValue.(lua.LString)
-		if !ok {
-			return "", "", errors.New("routing script ruleTag must be a string")
-		}
-		ruleTag = string(value)
-	}
-	return string(tag), ruleTag, nil
-}
-
-type processFinder func(string, string, uint16, string, uint16) (int, string, string, error)
-
-func findProcess(ctx routing.Context, finder processFinder) (int, string, string, error) {
-	sources := ctx.GetSourceIPs()
-	if len(sources) == 0 {
-		return 0, "", "", errors.New("process lookup requires a source IP")
-	}
-	var network string
-	switch ctx.GetNetwork() {
-	case net.Network_TCP:
-		network = "tcp"
-	case net.Network_UDP:
-		network = "udp"
-	default:
-		return 0, "", "", errors.New("process lookup requires TCP or UDP")
-	}
-	targetIP, targetPort := "", uint16(0)
-	if targets := ctx.GetTargetIPs(); len(targets) > 0 {
-		targetIP, targetPort = targets[0].String(), uint16(ctx.GetTargetPort())
-	}
-	return finder(network, sources[0].String(), uint16(ctx.GetSourcePort()), targetIP, targetPort)
-}
@@ -1,292 +0,0 @@
-package router
-
-import (
-	"context"
-	go_errors "errors"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/xtls/xray-core/common/geodata"
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/common/protocol"
-	"github.com/xtls/xray-core/common/session"
-	"github.com/xtls/xray-core/features/routing"
-	routing_session "github.com/xtls/xray-core/features/routing/session"
-	lua "github.com/yuin/gopher-lua"
-)
-
-type luaRouteTestContext struct {
-	*routing_session.Context
-	sourceIPs, targetIPs, localIPs []net.IP
-}
-
-func (c *luaRouteTestContext) GetSourceIPs() []net.IP { return c.sourceIPs }
-func (c *luaRouteTestContext) GetTargetIPs() []net.IP { return c.targetIPs }
-func (c *luaRouteTestContext) GetLocalIPs() []net.IP  { return c.localIPs }
-
-func newLuaRouteTestContext() *luaRouteTestContext {
-	return &luaRouteTestContext{
-		Context: &routing_session.Context{
-			Inbound: &session.Inbound{
-				Tag: "in", VlessRoute: 4321,
-				Source: net.TCPDestination(net.LocalHostIP, 1234),
-				Local:  net.TCPDestination(net.LocalHostIP, 5678),
-				User:   &protocol.MemoryUser{Email: "user@example.com"},
-			},
-			Outbound: &session.Outbound{
-				Target:      net.TCPDestination(net.LocalHostIP, 443),
-				RouteTarget: net.TCPDestination(net.DomainAddress("MiXeD.Example."), 443),
-			},
-			Content: &session.Content{
-				Protocol: "tls", Attributes: map[string]string{"key": "value"}, SkipDNSResolve: true,
-			},
-		},
-		sourceIPs: []net.IP{{127, 0, 0, 2}},
-		targetIPs: []net.IP{{127, 0, 0, 3}},
-		localIPs:  []net.IP{{127, 0, 0, 1}},
-	}
-}
-
-func newLuaRouterState(t *testing.T, script string) (*Router, *lua.LState) {
-	t.Helper()
-	r := new(Router)
-	if err := r.Init(context.Background(), &Config{}, nil, nil, nil); err != nil {
-		t.Fatal(err)
-	}
-	L := lua.NewState()
-	t.Cleanup(L.Close)
-	r.RegisterLua(L)
-	geodata.RegisterLua(L)
-	if err := L.DoString(script); err != nil {
-		t.Fatal(err)
-	}
-	return r, L
-}
-
-func TestLuaRouteBinding(t *testing.T) {
-	r, L := newLuaRouterState(t, `
-local router = require("xray.router")
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.0/8")
-assert(router.NetworkUnknown == 0 and router.NetworkTCP == 2)
-assert(router.NetworkUDP == 3 and router.NetworkUNIX == 4)
-assert(router.BuildIPMatcher == nil and router.BuildDomainMatcher == nil)
-function HandleRoute(ctx, inboundTag, sourcePort, targetPort, localPort,
-    targetDomain, network, protocol, user, vlessRoute, skipDNSResolve, ...)
-    assert(select("#", ...) == 0)
-    assert(inboundTag == "in" and sourcePort == 1234 and targetPort == 443 and localPort == 5678)
-    assert(targetDomain == "MiXeD.Example." and network == router.NetworkTCP)
-    assert(protocol == "tls" and user == "user@example.com" and vlessRoute == 4321 and skipDNSResolve)
-    assert(ctx.GetNetwork == nil and ctx.Context == nil)
-    savedContext = ctx
-    sourceIPs, targetIPs, localIPs = ctx:GetSourceIPs(), ctx:GetTargetIPs(), ctx:GetLocalIPs()
-    attributes = ctx:GetAttributes()
-    assert(matcher:AnyMatch(sourceIPs) and matcher:AnyMatch(targetIPs) and matcher:AnyMatch(localIPs))
-    assert(attributes.key == "value" and attributes.missing == nil)
-    assert(not pcall(function() attributes.key = "changed" end))
-    return "out", "rule"
-end`)
-
-	ctx := newLuaRouteTestContext()
-	tag, rule, err := r.CallLuaHook(L, context.Background(), ctx)
-	if err != nil || tag != "out" || rule != "rule" {
-		t.Fatalf("hook = %q, %q, %v", tag, rule, err)
-	}
-	if L.GetGlobal("savedContext").(*lua.LUserData).Value != ctx {
-		t.Fatal("routing context was copied")
-	}
-	for _, tc := range []struct {
-		name string
-		want []net.IP
-	}{
-		{"sourceIPs", ctx.sourceIPs},
-		{"targetIPs", ctx.targetIPs},
-		{"localIPs", ctx.localIPs},
-	} {
-		got := L.GetGlobal(tc.name).(*lua.LUserData).Value.([]net.IP)
-		if &got[0] != &tc.want[0] {
-			t.Fatalf("%s storage was copied", tc.name)
-		}
-	}
-	ctx.Content.Attributes["key"] = "updated"
-	L.SetGlobal("expectedOS", lua.LString(runtime.GOOS))
-	if err := L.DoString(`
-assert(attributes.key == "updated")
-assert(require("xray.router").LocalOS == expectedOS)`); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestLuaRouteResult(t *testing.T) {
-	nativeErr := go_errors.New("native failure")
-	for _, tc := range []struct {
-		name, body, tag, rule, wantErr string
-		native                         bool
-	}{
-		{name: "route", body: `return "out", "rule"`, tag: "out", rule: "rule"},
-		{name: "no match", body: `return nil`},
-		{name: "empty tag", body: `return ""`},
-		{name: "invalid tag", body: `return 1`, wantErr: "outboundTag"},
-		{name: "invalid rule", body: `return "out", false`, wantErr: "ruleTag"},
-		{name: "string error", body: `return nil, nil, "script failure"`, wantErr: "script failure"},
-		{name: "native error", body: `return nil, nil, nativeError`, native: true},
-		{name: "runtime error", body: `error("runtime failure")`, wantErr: "runtime failure"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			r, L := newLuaRouterState(t, "function HandleRoute() "+tc.body+" end")
-			value := L.NewUserData()
-			value.Value = nativeErr
-			L.SetGlobal("nativeError", value)
-			previous := context.WithValue(context.Background(), struct{}{}, true)
-			L.SetContext(previous)
-			L.Push(lua.LTrue)
-
-			tag, rule, err := r.CallLuaHook(L, context.Background(), &routing_session.Context{})
-			if tag != tc.tag || rule != tc.rule {
-				t.Fatalf("result = %q, %q, %v", tag, rule, err)
-			}
-			switch {
-			case tc.native:
-				if err != nativeErr {
-					t.Fatalf("error = %v, want original error", err)
-				}
-			case tc.wantErr != "":
-				if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
-					t.Fatalf("error = %v, want %q", err, tc.wantErr)
-				}
-			case err != nil:
-				t.Fatal(err)
-			}
-			if L.Context() != previous || L.GetTop() != 1 || L.Get(1) != lua.LTrue {
-				t.Fatal("hook did not restore the previous context and stack")
-			}
-		})
-	}
-}
-
-func TestLuaRouteCancellation(t *testing.T) {
-	r, L := newLuaRouterState(t, `function HandleRoute() while true do end end`)
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	if _, _, err := r.CallLuaHook(L, ctx, &routing_session.Context{}); err == nil {
-		t.Fatal("CallLuaHook did not stop after context cancellation")
-	}
-	if L.Context() != nil || L.GetTop() != 0 {
-		t.Fatal("CallLuaHook did not restore the Lua state")
-	}
-}
-
-func TestFindProcess(t *testing.T) {
-	for _, tc := range []struct {
-		name, network, target string
-		targetPort            uint16
-		modify                func(*luaRouteTestContext)
-		wantErr               bool
-	}{
-		{name: "TCP", network: "tcp", target: "127.0.0.3", targetPort: 443},
-		{name: "UDP", network: "udp", target: "127.0.0.3", targetPort: 443, modify: func(c *luaRouteTestContext) {
-			c.Outbound.Target.Network = net.Network_UDP
-		}},
-		{name: "domain target", network: "tcp", modify: func(c *luaRouteTestContext) { c.targetIPs = nil }},
-		{name: "missing source", modify: func(c *luaRouteTestContext) { c.sourceIPs = nil }, wantErr: true},
-		{name: "unsupported network", modify: func(c *luaRouteTestContext) {
-			c.Outbound.Target.Network = net.Network_UNIX
-		}, wantErr: true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			ctx := newLuaRouteTestContext()
-			if tc.modify != nil {
-				tc.modify(ctx)
-			}
-			called := false
-			pid, name, path, err := findProcess(ctx, func(network, source string, sourcePort uint16, target string, targetPort uint16) (int, string, string, error) {
-				called = true
-				if network != tc.network || source != "127.0.0.2" || sourcePort != 1234 || target != tc.target || targetPort != tc.targetPort {
-					t.Fatalf("endpoints = %s %s:%d -> %s:%d", network, source, sourcePort, target, targetPort)
-				}
-				return 42, "process", "/path/process", nil
-			})
-			if tc.wantErr {
-				if err == nil || called {
-					t.Fatalf("findProcess = %d, %q, %q, %v", pid, name, path, err)
-				}
-				return
-			}
-			if err != nil || !called || pid != 42 || name != "process" || path != "/path/process" {
-				t.Fatalf("findProcess = %d, %q, %q, %v", pid, name, path, err)
-			}
-		})
-	}
-}
-
-// BenchmarkLuaRouteHookCall isolates a preloaded Lua hook and its routing context bridge.
-// The direct case runs an equivalent native routing rule.
-func BenchmarkLuaRouteHookCall(b *testing.B) {
-	r := new(Router)
-	if err := r.Init(context.Background(), &Config{Rule: []*RoutingRule{{
-		TargetTag:  &RoutingRule_Tag{Tag: "out"},
-		RuleTag:    "rule",
-		InboundTag: []string{"in"},
-		Networks:   []net.Network{net.Network_TCP},
-		Ip: []*geodata.IPRule{{
-			Value: &geodata.IPRule_Custom{Custom: &geodata.CIDRRule{
-				Cidr: &geodata.CIDR{Ip: []byte{127, 0, 0, 0}, Prefix: 8},
-			}},
-		}},
-	}}}, nil, nil, nil); err != nil {
-		b.Fatal(err)
-	}
-	L := lua.NewState()
-	defer L.Close()
-	r.RegisterLua(L)
-	geodata.RegisterLua(L)
-	if err := L.DoString(`
-local router = require("xray.router")
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.0/8")
-function HandleRoute(ctx, inboundTag, sourcePort, targetPort, localPort,
-    targetDomain, network, protocol, user, vlessRoute, skipDNSResolve)
-    if inboundTag == "in" and network == router.NetworkTCP and matcher:AnyMatch(ctx:GetTargetIPs()) then
-        return "out", "rule"
-    end
-end
-`); err != nil {
-		b.Fatal(err)
-	}
-
-	ctx := context.Background()
-	routeCtx := newLuaRouteTestContext()
-	for _, benchmark := range []struct {
-		name  string
-		route func() (string, string, error)
-	}{
-		{"direct", func() (string, string, error) {
-			route, err := r.PickRoute(routeCtx)
-			if err != nil {
-				return "", "", err
-			}
-			return route.GetOutboundTag(), route.GetRuleTag(), nil
-		}},
-		{"lua_hook", func() (string, string, error) {
-			return r.CallLuaHook(L, ctx, routeCtx)
-		}},
-	} {
-		b.Run(benchmark.name, func(b *testing.B) {
-			b.ReportAllocs()
-			b.ResetTimer()
-			var tag, rule string
-			var err error
-			for i := 0; i < b.N; i++ {
-				tag, rule, err = benchmark.route()
-				if err != nil {
-					b.Fatal(err)
-				}
-			}
-			b.StopTimer()
-			if tag != "out" || rule != "rule" {
-				b.Fatalf("route() = %q, %q; want out, rule", tag, rule)
-			}
-		})
-	}
-}
-
-var _ routing.Context = (*luaRouteTestContext)(nil)
@@ -2,9 +2,7 @@ package router

 import (
 	"context"
-	"maps"
 	"sync"
-	"sync/atomic"

 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
@@ -19,10 +17,8 @@ import (
 // Router is an implementation of routing.Router.
 type Router struct {
 	domainStrategy Config_DomainStrategy
-	rules          atomic.Pointer[[]*Rule]
-	scriptPath     string
-	script         *scriptEngine
-	balancers      atomic.Pointer[map[string]*Balancer]
+	rules          []*Rule
+	balancers      map[string]*Balancer
 	dns            dns.Client

 	ctx        context.Context
@@ -42,23 +38,61 @@ type Route struct {
 // Init initializes the Router.
 func (r *Router) Init(ctx context.Context, config *Config, d dns.Client, ohm outbound.Manager, dispatcher routing.Dispatcher) error {
 	r.domainStrategy = config.DomainStrategy
-	r.scriptPath = config.Script
 	r.dns = d
 	r.ctx = ctx
 	r.ohm = ohm
 	r.dispatcher = dispatcher

-	r.rules.Store(new([]*Rule))
-	r.balancers.Store(&map[string]*Balancer{})
-	return r.ReloadRules(config, false)
+	r.balancers = make(map[string]*Balancer, len(config.BalancingRule))
+	for _, rule := range config.BalancingRule {
+		balancer, err := rule.Build(ohm, dispatcher)
+		if err != nil {
+			return err
+		}
+		balancer.InjectContext(ctx)
+		r.balancers[rule.Tag] = balancer
+	}
+
+	r.rules = make([]*Rule, 0, len(config.Rule))
+	for _, rule := range config.Rule {
+		cond, err := rule.BuildCondition()
+		if err != nil {
+			r.closeWebhooks()
+			return err
+		}
+		rr := &Rule{
+			Condition: cond,
+			Tag:       rule.GetTag(),
+			RuleTag:   rule.GetRuleTag(),
+		}
+		if wh := rule.GetWebhook(); wh != nil {
+			notifier, err := NewWebhookNotifier(wh)
+			if err != nil {
+				r.closeWebhooks()
+				return err
+			}
+			rr.Webhook = notifier
+		}
+		btag := rule.GetBalancingTag()
+		if len(btag) > 0 {
+			brule, found := r.balancers[btag]
+			if !found {
+				if rr.Webhook != nil {
+					rr.Webhook.Close()
+				}
+				r.closeWebhooks()
+				return errors.New("balancer ", btag, " not found")
+			}
+			rr.Balancer = brule
+		}
+		r.rules = append(r.rules, rr)
+	}
+
+	return nil
 }

 // PickRoute implements routing.Router.
 func (r *Router) PickRoute(ctx routing.Context) (routing.Route, error) {
-	if r.script != nil {
-		return r.script.pickRoute(ctx)
-	}
-
 	originalCtx := ctx
 	rule, ctx, err := r.pickRouteInternal(ctx)
 	if err != nil {
@@ -76,6 +110,7 @@ func (r *Router) PickRoute(ctx routing.Context) (routing.Route, error) {

 // AddRule implements routing.Router.
 func (r *Router) AddRule(config *serial.TypedMessage, shouldAppend bool) error {
+
 	inst, err := config.GetInstance()
 	if err != nil {
 		return err
@@ -90,22 +125,18 @@ func (r *Router) ReloadRules(config *Config, shouldAppend bool) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()

-	oldRules := *r.rules.Load()
-	oldBalancers := *r.balancers.Load()
-
-	var newRules []*Rule
-	newBalancers := make(map[string]*Balancer)
-	existTags := make(map[string]bool, len(oldRules)+len(config.Rule))
-	if shouldAppend {
-		newRules = append(newRules, oldRules...)
-		maps.Copy(newBalancers, oldBalancers)
-		for _, rule := range oldRules {
-			existTags[rule.RuleTag] = true
+	if !shouldAppend {
+		for _, rule := range r.rules {
+			if rule.Webhook != nil {
+				rule.Webhook.Close()
+			}
 		}
+		r.balancers = make(map[string]*Balancer, len(config.BalancingRule))
+		r.rules = make([]*Rule, 0, len(config.Rule))
 	}
-
 	for _, rule := range config.BalancingRule {
-		if _, found := newBalancers[rule.Tag]; found {
+		_, found := r.balancers[rule.Tag]
+		if found {
 			return errors.New("duplicate balancer tag")
 		}
 		balancer, err := rule.Build(r.ohm, r.dispatcher)
@@ -113,12 +144,27 @@ func (r *Router) ReloadRules(config *Config, shouldAppend bool) error {
 			return err
 		}
 		balancer.InjectContext(r.ctx)
-		newBalancers[rule.Tag] = balancer
+		r.balancers[rule.Tag] = balancer
+	}
+
+	startIdx := len(r.rules)
+	closeNewWebhooks := func() {
+		for i := startIdx; i < len(r.rules); i++ {
+			if r.rules[i].Webhook != nil {
+				r.rules[i].Webhook.Close()
+			}
+		}
+		r.rules = r.rules[:startIdx]
 	}

 	for _, rule := range config.Rule {
+		if r.RuleExists(rule.GetRuleTag()) {
+			closeNewWebhooks()
+			return errors.New("duplicate ruleTag ", rule.GetRuleTag())
+		}
 		cond, err := rule.BuildCondition()
 		if err != nil {
+			closeNewWebhooks()
 			return err
 		}
 		rr := &Rule{
@@ -126,64 +172,70 @@ func (r *Router) ReloadRules(config *Config, shouldAppend bool) error {
 			Tag:       rule.GetTag(),
 			RuleTag:   rule.GetRuleTag(),
 		}
-		if rr.RuleTag != "" && existTags[rr.RuleTag] {
-			return errors.New("duplicate ruleTag ", rr.RuleTag)
-		}
-		existTags[rr.RuleTag] = true
 		if wh := rule.GetWebhook(); wh != nil {
 			notifier, err := NewWebhookNotifier(wh)
 			if err != nil {
+				closeNewWebhooks()
 				return err
 			}
 			rr.Webhook = notifier
 		}
-		if btag := rule.GetBalancingTag(); len(btag) > 0 {
-			brule, found := newBalancers[btag]
+		btag := rule.GetBalancingTag()
+		if len(btag) > 0 {
+			brule, found := r.balancers[btag]
 			if !found {
+				if rr.Webhook != nil {
+					rr.Webhook.Close()
+				}
+				closeNewWebhooks()
 				return errors.New("balancer ", btag, " not found")
 			}
 			rr.Balancer = brule
 		}
-		newRules = append(newRules, rr)
+		r.rules = append(r.rules, rr)
 	}

-	r.balancers.Store(&newBalancers)
-	r.rules.Store(&newRules)
-	if !shouldAppend {
-		closeWebhooks(oldRules)
-	}
 	return nil
 }

+func (r *Router) RuleExists(tag string) bool {
+	if tag != "" {
+		for _, rule := range r.rules {
+			if rule.RuleTag == tag {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // RemoveRule implements routing.Router.
 func (r *Router) RemoveRule(tag string) error {
-	if tag == "" {
-		return errors.New("empty tag name!")
-	}
-
 	r.mu.Lock()
 	defer r.mu.Unlock()

-	oldRules := *r.rules.Load()
-	newRules := make([]*Rule, 0, len(oldRules))
-	var removed []*Rule
-	for _, rule := range oldRules {
-		if rule.RuleTag != tag {
-			newRules = append(newRules, rule)
-		} else {
-			removed = append(removed, rule)
+	newRules := []*Rule{}
+	if tag != "" {
+		for _, rule := range r.rules {
+			if rule.RuleTag != tag {
+				newRules = append(newRules, rule)
+			} else if rule.Webhook != nil {
+				rule.Webhook.Close()
+			}
 		}
+		r.rules = newRules
+		return nil
 	}
-	r.rules.Store(&newRules)
-	closeWebhooks(removed)
-	return nil
+	return errors.New("empty tag name!")
+
 }

 // ListRule implements routing.Router
 func (r *Router) ListRule() []routing.Route {
-	rules := *r.rules.Load()
-	ruleList := make([]routing.Route, 0, len(rules))
-	for _, rule := range rules {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	ruleList := make([]routing.Route, 0)
+	for _, rule := range r.rules {
 		ruleList = append(ruleList, &Route{
 			outboundTag: rule.Tag,
 			ruleTag:     rule.RuleTag,
@@ -202,9 +254,7 @@ func (r *Router) pickRouteInternal(ctx routing.Context) (*Rule, routing.Context,
 		ctx = routing_dns.ContextWithDNSClient(ctx, r.dns)
 	}

-	rules := *r.rules.Load()
-
-	for _, rule := range rules {
+	for _, rule := range r.rules {
 		if rule.Apply(ctx) {
 			return rule, ctx, nil
 		}
@@ -217,7 +267,7 @@ func (r *Router) pickRouteInternal(ctx routing.Context) (*Rule, routing.Context,
 	ctx = routing_dns.ContextWithDNSClient(ctx, r.dns)

 	// Try applying rules again if we have IPs.
-	for _, rule := range rules {
+	for _, rule := range r.rules {
 		if rule.Apply(ctx) {
 			return rule, ctx, nil
 		}
@@ -228,19 +278,12 @@ func (r *Router) pickRouteInternal(ctx routing.Context) (*Rule, routing.Context,

 // Start implements common.Runnable.
 func (r *Router) Start() error {
-	if r.scriptPath != "" {
-		engine, err := newScriptEngine(r.scriptPath, r)
-		if err != nil {
-			return errors.New("failed to initialize routing script").Base(err)
-		}
-		r.script = engine
-	}
 	return nil
 }

-// closeWebhooks closes all webhook notifiers in the given rule set.
-func closeWebhooks(rules []*Rule) {
-	for _, rule := range rules {
+// closeWebhooks closes all webhook notifiers in the current rule set.
+func (r *Router) closeWebhooks() {
+	for _, rule := range r.rules {
 		if rule.Webhook != nil {
 			rule.Webhook.Close()
 		}
@@ -249,12 +292,9 @@ func closeWebhooks(rules []*Rule) {

 // Close implements common.Closable.
 func (r *Router) Close() error {
-	if r.script != nil {
-		r.script.close()
-	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	closeWebhooks(*r.rules.Load())
+	r.closeWebhooks()
 	return nil
 }

@@ -1,79 +0,0 @@
-package router
-
-import (
-	"context"
-	"time"
-
-	"github.com/xtls/xray-core/app/dns"
-	"github.com/xtls/xray-core/common"
-	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/geodata"
-	"github.com/xtls/xray-core/common/log"
-	luamgr "github.com/xtls/xray-core/common/lua"
-	"github.com/xtls/xray-core/features/routing"
-	lua "github.com/yuin/gopher-lua"
-)
-
-const scriptExecutionTimeout = 10 * time.Second
-
-type scriptEngine struct {
-	router *Router
-	pool   *luamgr.Pool
-}
-
-func newScriptEngine(path string, router *Router) (*scriptEngine, error) {
-	program, err := luamgr.CompileFile(path)
-	if err != nil {
-		return nil, err
-	}
-	e := &scriptEngine{router: router}
-	e.pool, err = luamgr.NewPool(router.ctx, func(poolCtx context.Context) (*lua.LState, error) {
-		initCtx, cancel := context.WithTimeout(poolCtx, scriptExecutionTimeout)
-		defer cancel()
-		L, err := program.NewState(initCtx, func(L *lua.LState) {
-			geodata.RegisterLua(L)
-			log.RegisterLua(L)
-			router.RegisterLua(L)
-			dns.RegisterLua(L, router.dns)
-		})
-		if err != nil {
-			return nil, err
-		}
-		if L.GetGlobal("HandleRoute").Type() != lua.LTFunction {
-			L.Close()
-			return nil, errors.New("routing script must define HandleRoute(...)")
-		}
-		return L, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	errors.LogInfo(router.ctx, "routing script initialized from ", path)
-	return e, nil
-}
-
-func (e *scriptEngine) close() {
-	e.pool.Close()
-}
-
-func (e *scriptEngine) pickRoute(ctx routing.Context) (routing.Route, error) {
-	L, err := e.pool.Acquire()
-	if err != nil {
-		return nil, err
-	}
-	reusable := false
-	defer func() {
-		e.pool.Release(L, reusable)
-	}()
-	callCtx, cancel := context.WithTimeout(e.pool.Context(), scriptExecutionTimeout)
-	defer cancel()
-	tag, ruleTag, err := e.router.CallLuaHook(L, callCtx, ctx)
-	if err != nil {
-		return nil, err
-	}
-	reusable = true
-	if tag == "" {
-		return nil, common.ErrNoClue
-	}
-	return &Route{Context: ctx, outboundTag: tag, ruleTag: ruleTag}, nil
-}
@@ -1,372 +0,0 @@
-package router
-
-import (
-	"context"
-	stdnet "net"
-	"os"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	wireDNS "github.com/miekg/dns"
-	"github.com/xtls/xray-core/app/dispatcher"
-	appdns "github.com/xtls/xray-core/app/dns"
-	"github.com/xtls/xray-core/app/proxyman"
-	_ "github.com/xtls/xray-core/app/proxyman/outbound"
-	"github.com/xtls/xray-core/common"
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/common/serial"
-	"github.com/xtls/xray-core/core"
-	featureDNS "github.com/xtls/xray-core/features/dns"
-	"github.com/xtls/xray-core/features/outbound"
-	"github.com/xtls/xray-core/features/routing"
-	routing_session "github.com/xtls/xray-core/features/routing/session"
-	"github.com/xtls/xray-core/proxy/blackhole"
-	"github.com/xtls/xray-core/proxy/freedom"
-)
-
-type luaRouteDNSClient struct {
-	featureDNS.Client
-	lookup func(string, featureDNS.IPOption) ([]net.IP, uint32, error)
-}
-
-func (d *luaRouteDNSClient) LookupIP(domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-	return d.lookup(domain, option)
-}
-
-type luaRouteOutboundManager struct{ outbound.Manager }
-
-func (*luaRouteOutboundManager) Select(selectors []string) []string { return selectors }
-
-func writeRouteScript(t *testing.T, script string) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "route.lua")
-	if err := os.WriteFile(path, []byte(script), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	return path
-}
-
-func startLuaRouter(t *testing.T, script string, d featureDNS.Client, config *Config) *Router {
-	t.Helper()
-	if config == nil {
-		config = &Config{}
-	}
-	config.Script = writeRouteScript(t, script)
-	r := new(Router)
-	if err := r.Init(context.Background(), config, d, &luaRouteOutboundManager{}, nil); err != nil {
-		t.Fatal(err)
-	}
-	if err := r.Start(); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		if err := r.Close(); err != nil {
-			t.Error(err)
-		}
-	})
-	return r
-}
-
-func TestRouterScriptStartup(t *testing.T) {
-	for _, tc := range []struct{ name, script string }{
-		{"syntax error", "function HandleRoute("},
-		{"missing hook", "value = 1"},
-		{"initialization error", `error("setup failed")`},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			r := new(Router)
-			if err := r.Init(context.Background(), &Config{Script: writeRouteScript(t, tc.script)}, nil, nil, nil); err != nil {
-				t.Fatal(err)
-			}
-			defer r.Close()
-			if err := r.Start(); err == nil {
-				t.Fatal("Start accepted an invalid routing script")
-			}
-		})
-	}
-}
-
-func TestRouterScriptRouting(t *testing.T) {
-	var dnsCalls atomic.Int32
-	d := &luaRouteDNSClient{lookup: func(string, featureDNS.IPOption) ([]net.IP, uint32, error) {
-		dnsCalls.Add(1)
-		return []net.IP{{1, 2, 3, 4}}, 60, nil
-	}}
-	r := startLuaRouter(t, `
-function HandleRoute(ctx, inbound)
-    if inbound == "miss" then return nil end
-    return "lua-out", "lua-rule"
-end`, d, &Config{
-		DomainStrategy: Config_IpOnDemand,
-		Rule: []*RoutingRule{{
-			TargetTag: &RoutingRule_Tag{Tag: "json-out"},
-			Networks:  []net.Network{net.Network_TCP},
-		}},
-	})
-	ctx := newLuaRouteTestContext()
-	ctx.Content.SkipDNSResolve = false
-	route, err := r.PickRoute(ctx)
-	if err != nil || route.GetOutboundTag() != "lua-out" || route.GetRuleTag() != "lua-rule" || route.(*Route).Context != ctx {
-		t.Fatalf("route = %v, %v", route, err)
-	}
-	ctx.Inbound.Tag = "miss"
-	if route, err := r.PickRoute(ctx); route != nil || err != common.ErrNoClue {
-		t.Fatalf("miss = %v, %v", route, err)
-	}
-	if dnsCalls.Load() != 0 {
-		t.Fatal("script routing implicitly resolved DNS")
-	}
-}
-
-func TestRouterScriptModules(t *testing.T) {
-	ips := []net.IP{{127, 0, 0, 7}}
-	calls := 0
-	d := &luaRouteDNSClient{lookup: func(domain string, option featureDNS.IPOption) ([]net.IP, uint32, error) {
-		calls++
-		if domain != "MiXeD.Example." || !option.IPv4Enable || option.IPv6Enable || !option.FakeEnable {
-			t.Fatalf("dns.Query arguments = %q, %+v", domain, option)
-		}
-		return ips, 17, nil
-	}}
-	r := startLuaRouter(t, `
-local dns = require("xray.dns")
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.0/8")
-assert(dns.Servers == nil and type(dns.Query) == "function")
-assert(type(require("xray.log").Info) == "function")
-function HandleRoute(ctx, inbound, sourcePort, targetPort, localPort, domain)
-    local ips, ttl, err = dns.Query(domain, true, false, true)
-    assert(not err and ttl == 17)
-    assert(matcher:AnyMatch(ips) and matcher:AnyMatch(ctx:GetTargetIPs()))
-    return "out"
-end`, d, nil)
-	if _, err := r.PickRoute(newLuaRouteTestContext()); err != nil {
-		t.Fatal(err)
-	}
-	if calls != 1 {
-		t.Fatalf("DNS calls = %d, want 1", calls)
-	}
-}
-
-func TestRouterScriptBalancerReload(t *testing.T) {
-	config := func(tag string) *Config {
-		return &Config{BalancingRule: []*BalancingRule{{
-			Tag: "balance", Strategy: "roundrobin", OutboundSelector: []string{tag},
-		}}}
-	}
-	r := startLuaRouter(t, `
-local router = require("xray.router")
-function HandleRoute()
-    local tag, err = router:PickOutbound("balance")
-    return tag, "balanced", err
-end`, nil, config("old"))
-	pick := func(want string) {
-		t.Helper()
-		route, err := r.PickRoute(&routing_session.Context{})
-		if err != nil || route.GetOutboundTag() != want || route.GetRuleTag() != "balanced" {
-			t.Fatalf("route = %v, %v, want %q", route, err, want)
-		}
-	}
-
-	pick("old")
-	if err := r.SetOverrideTarget("balance", "override"); err != nil {
-		t.Fatal(err)
-	}
-	pick("override")
-	if err := r.SetOverrideTarget("balance", ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := r.ReloadRules(config("new"), false); err != nil {
-		t.Fatal(err)
-	}
-	pick("new")
-}
-
-func TestRouterScriptConcurrentBalancerReload(t *testing.T) {
-	config := func(tag string) *Config {
-		return &Config{BalancingRule: []*BalancingRule{{
-			Tag: "balance", Strategy: "roundrobin", OutboundSelector: []string{tag},
-		}}}
-	}
-	r := startLuaRouter(t, `
-local router = require("xray.router")
-function HandleRoute()
-    local tag, err = router:PickOutbound("balance")
-    return tag, nil, err
-end`, nil, config("a"))
-
-	var wg sync.WaitGroup
-	for range 4 {
-		wg.Go(func() {
-			for range 20 {
-				route, err := r.PickRoute(&routing_session.Context{})
-				if err != nil {
-					t.Errorf("PickRoute: %v", err)
-					return
-				}
-				if tag := route.GetOutboundTag(); tag != "a" && tag != "b" {
-					t.Errorf("unexpected tag %q", tag)
-				}
-			}
-		})
-	}
-	wg.Go(func() {
-		for range 20 {
-			for _, tag := range []string{"a", "b"} {
-				if err := r.ReloadRules(config(tag), false); err != nil {
-					t.Error(err)
-					return
-				}
-			}
-		}
-	})
-	wg.Wait()
-}
-
-func TestRouterScriptStateReuse(t *testing.T) {
-	r := startLuaRouter(t, `
-local calls = 0
-function HandleRoute(ctx, inbound)
-    calls = calls + 1
-    if inbound == "miss" then return nil end
-    if inbound == "fail" then error("failed") end
-    return tostring(calls)
-end`, nil, nil)
-	ctx := newLuaRouteTestContext()
-	pick := func(want string) {
-		t.Helper()
-		route, err := r.PickRoute(ctx)
-		if err != nil || route.GetOutboundTag() != want {
-			t.Fatalf("route = %v, %v, want %q", route, err, want)
-		}
-	}
-
-	pick("1")
-	ctx.Inbound.Tag = "miss"
-	if _, err := r.PickRoute(ctx); err != common.ErrNoClue {
-		t.Fatalf("miss = %v", err)
-	}
-	ctx.Inbound.Tag = "in"
-	pick("3")
-	ctx.Inbound.Tag = "fail"
-	if _, err := r.PickRoute(ctx); err == nil {
-		t.Fatal("script error was ignored")
-	}
-	ctx.Inbound.Tag = "in"
-	pick("1")
-}
-
-func TestRouterScriptDNSDispatcherReentry(t *testing.T) {
-	conn, err := stdnet.ListenPacket("udp4", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	port := conn.LocalAddr().(*stdnet.UDPAddr).Port
-	ready, stopped := make(chan struct{}), make(chan error, 1)
-	var queries atomic.Int32
-	server := &wireDNS.Server{
-		PacketConn: conn,
-		NotifyStartedFunc: func() {
-			close(ready)
-		},
-		Handler: wireDNS.HandlerFunc(func(w wireDNS.ResponseWriter, query *wireDNS.Msg) {
-			queries.Add(1)
-			response := new(wireDNS.Msg).SetReply(query)
-			for _, question := range query.Question {
-				if question.Name == "nested.example." && question.Qtype == wireDNS.TypeA {
-					response.Answer = append(response.Answer, &wireDNS.A{
-						Hdr: wireDNS.RR_Header{Name: question.Name, Rrtype: wireDNS.TypeA, Class: wireDNS.ClassINET, Ttl: 60},
-						A:   stdnet.IP{127, 0, 0, 7},
-					})
-				}
-			}
-			if err := w.WriteMsg(response); err != nil {
-				t.Error(err)
-			}
-		}),
-	}
-	go func() { stopped <- server.ActivateAndServe() }()
-	defer func() {
-		server.Shutdown()
-		select {
-		case err := <-stopped:
-			if err != nil {
-				t.Error(err)
-			}
-		case <-time.After(3 * time.Second):
-			t.Error("DNS server did not stop")
-		}
-	}()
-	select {
-	case <-ready:
-	case err := <-stopped:
-		t.Fatalf("DNS server startup: %v", err)
-	case <-time.After(3 * time.Second):
-		t.Fatal("DNS server did not start")
-	}
-
-	dnsScript := writeRouteScript(t, `
-local server = require("xray.dns").Servers[1]
-function HandleDNSQuery(domain, ipv4, ipv6, fake)
-    return server:Query(domain, ipv4, ipv6, fake)
-end`)
-	routerScript := writeRouteScript(t, `
-local router = require("xray.router")
-local dns = require("xray.dns")
-local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.7")
-local active = false
-function HandleRoute(ctx, inbound, sourcePort, targetPort, localPort, domain, network,
-    protocol, user, vlessRoute, skipDNSResolve)
-    assert(not active, "borrowed Router VM reentered")
-    if inbound == "dns" then
-        assert(network == router.NetworkUDP and skipDNSResolve == false)
-        return "direct", "dns-route"
-    end
-    active = true
-    local ips, ttl, err = dns.Query("nested.example", true, false, false)
-    assert(not err and matcher:AnyMatch(ips) and active)
-    active = false
-    return "direct", "outer-route"
-end`)
-	instance, err := core.New(&core.Config{
-		App: []*serial.TypedMessage{
-			serial.ToTypedMessage(&appdns.Config{
-				Tag: "dns", Script: dnsScript, DisableCache: true,
-				NameServer: []*appdns.NameServer{{
-					Id: "upstream", TimeoutMs: 1000,
-					Address: &net.Endpoint{
-						Network: net.Network_UDP,
-						Address: &net.IPOrDomain{Address: &net.IPOrDomain_Ip{Ip: []byte{127, 0, 0, 1}}},
-						Port:    uint32(port),
-					},
-				}},
-			}),
-			serial.ToTypedMessage(&Config{Script: routerScript}),
-			serial.ToTypedMessage(&dispatcher.Config{}),
-			serial.ToTypedMessage(&proxyman.OutboundConfig{}),
-		},
-		Outbound: []*core.OutboundHandlerConfig{
-			{Tag: "default", ProxySettings: serial.ToTypedMessage(&blackhole.Config{})},
-			{Tag: "direct", ProxySettings: serial.ToTypedMessage(&freedom.Config{
-				FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}},
-			})},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer instance.Close()
-	if err := instance.Start(); err != nil {
-		t.Fatal(err)
-	}
-	r := instance.GetFeature(routing.RouterType()).(*Router)
-	route, err := r.PickRoute(newLuaRouteTestContext())
-	if err != nil || route.GetOutboundTag() != "direct" || route.GetRuleTag() != "outer-route" {
-		t.Fatalf("nested DNS routing = %v, %v", route, err)
-	}
-	if queries.Load() == 0 {
-		t.Fatal("DNS query did not pass through the dispatcher")
-	}
-}
@@ -3,7 +3,6 @@ package router
 import (
 	"context"
 	"math"
-	"slices"
 	"sort"
 	"time"

@@ -78,7 +77,7 @@ func (s *LeastLoadStrategy) PickOutbound(candidates []string) string {
 }

 func (s *LeastLoadStrategy) pickOutbounds(candidates []string) []*node {
-	qualified := s.getNodes(candidates)
+	qualified := s.getNodes(candidates, time.Duration(s.settings.MaxRTT))
 	selects := s.selectLeastLoad(qualified)
 	return selects
 }
@@ -139,7 +138,7 @@ func (s *LeastLoadStrategy) selectLeastLoad(nodes []*node) []*node {
 	return nodes[:count]
 }

-func (s *LeastLoadStrategy) getNodes(candidates []string) []*node {
+func (s *LeastLoadStrategy) getNodes(candidates []string, maxRTT time.Duration) []*node {
 	if s.observer == nil {
 		errors.LogError(s.ctx, "observer is nil")
 		return make([]*node, 0)
@@ -152,10 +151,12 @@ func (s *LeastLoadStrategy) getNodes(candidates []string) []*node {

 	results := observeResult.(*observatory.ObservationResult)

+	outboundlist := outboundList(candidates)
+
 	var ret []*node

 	for _, v := range results.Status {
-		if s.shouldSelectNode(v, candidates) {
+		if v.Alive && (v.Delay < maxRTT.Milliseconds() || maxRTT == 0) && outboundlist.contains(v.OutboundTag) {
 			record := &node{
 				Tag:              v.OutboundTag,
 				CountAll:         1,
@@ -171,8 +172,8 @@ func (s *LeastLoadStrategy) getNodes(candidates []string) []*node {
 				record.RTTDeviationCost = time.Duration(s.costs.Apply(v.OutboundTag, float64(v.HealthPing.Deviation)))
 				record.CountAll = int(v.HealthPing.All)
 				record.CountFail = int(v.HealthPing.Fail)
-			}

+			}
 			ret = append(ret, record)
 		}
 	}
@@ -181,23 +182,6 @@ func (s *LeastLoadStrategy) getNodes(candidates []string) []*node {
 	return ret
 }

-func (s *LeastLoadStrategy) shouldSelectNode(v *observatory.OutboundStatus, candidates []string) bool {
-	maxRTT := time.Duration(s.settings.MaxRTT)
-	if !v.Alive {
-		return false
-	}
-	if maxRTT != 0 && v.Delay >= maxRTT.Milliseconds() {
-		return false
-	}
-	if !slices.Contains(candidates, v.OutboundTag) {
-		return false
-	}
-	if v.HealthPing != nil && v.HealthPing.All > 0 && s.settings.Tolerance > 0 && float64(v.HealthPing.Fail)/float64(v.HealthPing.All) > float64(s.settings.Tolerance) {
-		return false
-	}
-	return true
-}
-
 func leastloadSort(nodes []*node) {
 	sort.Slice(nodes, func(i, j int) bool {
 		left := nodes[i]
@@ -85,7 +85,6 @@ func TestSelectLeastExpected(t *testing.T) {
 		t.Errorf("expected: %v, actual: %v", expected, len(ns))
 	}
 }
-
 func TestSelectLeastExpected2(t *testing.T) {
 	strategy := &LeastLoadStrategy{
 		settings: &StrategyLeastLoadConfig{
@@ -103,7 +102,6 @@ func TestSelectLeastExpected2(t *testing.T) {
 		t.Errorf("expected: %v, actual: %v", expected, len(ns))
 	}
 }
-
 func TestSelectLeastExpectedAndBaselines(t *testing.T) {
 	strategy := &LeastLoadStrategy{
 		settings: &StrategyLeastLoadConfig{
@@ -124,7 +122,6 @@ func TestSelectLeastExpectedAndBaselines(t *testing.T) {
 		t.Errorf("expected: %v, actual: %v", expected, len(ns))
 	}
 }
-
 func TestSelectLeastExpectedAndBaselines2(t *testing.T) {
 	strategy := &LeastLoadStrategy{
 		settings: &StrategyLeastLoadConfig{
@@ -145,7 +142,6 @@ func TestSelectLeastExpectedAndBaselines2(t *testing.T) {
 		t.Errorf("expected: %v, actual: %v", expected, len(ns))
 	}
 }
-
 func TestSelectLeastLoadBaselines(t *testing.T) {
 	strategy := &LeastLoadStrategy{
 		settings: &StrategyLeastLoadConfig{
@@ -164,7 +160,6 @@ func TestSelectLeastLoadBaselines(t *testing.T) {
 		t.Errorf("expected: %v, actual: %v", expected, len(ns))
 	}
 }
-
 func TestSelectLeastLoadBaselinesNoQualified(t *testing.T) {
 	strategy := &LeastLoadStrategy{
 		settings: &StrategyLeastLoadConfig{
@@ -7,16 +7,61 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"path/filepath"
+	"runtime"
+	"strings"
 	"sync"
-	"sync/atomic"
+	"syscall"
 	"time"

 	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/utils"
 	"github.com/xtls/xray-core/features/routing"
 	routing_session "github.com/xtls/xray-core/features/routing/session"
 )

+// parseURL splits a webhook URL into an HTTP URL and an optional Unix socket
+// path. For regular http/https URLs the input is returned unchanged with an
+// empty socketPath. For Unix sockets the format is:
+//
+//	/path/to/socket.sock:/http/path
+//	@abstract:/http/path
+//	@@padded:/http/path
+//
+// The :/ separator after the socket path delimits the HTTP request path.
+// If omitted, "/" is used.
+func parseURL(raw string) (httpURL, socketPath string) {
+	if len(raw) == 0 || (!filepath.IsAbs(raw) && raw[0] != '@') {
+		return raw, ""
+	}
+	if idx := strings.Index(raw, ":/"); idx >= 0 {
+		return "http://localhost" + raw[idx+1:], raw[:idx]
+	}
+	return "http://localhost/", raw
+}
+
+// resolveSocketPath applies platform-specific transformations to a Unix
+// socket path, matching the behaviour of the listen side in
+// transport/internet/system_listener.go.
+//
+// For abstract sockets (prefix @) on Linux/Android:
+//   - single @ — used as-is (lock-free abstract socket)
+//   - double @@ — stripped to single @ and padded to
+//     syscall.RawSockaddrUnix{}.Path length (HAProxy compat)
+func resolveSocketPath(path string) string {
+	if len(path) == 0 || path[0] != '@' {
+		return path
+	}
+	if runtime.GOOS != "linux" && runtime.GOOS != "android" {
+		return path
+	}
+	if len(path) > 1 && path[1] == '@' {
+		fullAddr := make([]byte, len(syscall.RawSockaddrUnix{}.Path))
+		copy(fullAddr, path[1:])
+		return string(fullAddr)
+	}
+	return path
+}
+
 func ptr[T any](v T) *T { return &v }

 type event struct {
@@ -41,7 +86,6 @@ type WebhookNotifier struct {
 	deduplication uint32
 	client        *http.Client
 	seen          sync.Map
-	lastSweep     atomic.Int64
 	done          chan struct{}
 	wg            sync.WaitGroup
 	closeOnce     sync.Once
@@ -52,7 +96,7 @@ func NewWebhookNotifier(cfg *WebhookConfig) (*WebhookNotifier, error) {
 		return nil, nil
 	}

-	httpURL, socketPath := utils.SplitHTTPUnixURL(cfg.Url)
+	httpURL, socketPath := parseURL(cfg.Url)
 	h := &WebhookNotifier{
 		url:           httpURL,
 		deduplication: cfg.Deduplication,
@@ -63,7 +107,7 @@ func NewWebhookNotifier(cfg *WebhookConfig) (*WebhookNotifier, error) {
 	}

 	if socketPath != "" {
-		dialAddr := utils.ResolveSocketPath(socketPath)
+		dialAddr := resolveSocketPath(socketPath)
 		h.client.Transport = &http.Transport{
 			DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
 				var d net.Dialer
@@ -79,6 +123,11 @@ func NewWebhookNotifier(cfg *WebhookConfig) (*WebhookNotifier, error) {
 		}
 	}

+	if h.deduplication > 0 {
+		h.wg.Add(1)
+		go h.cleanupLoop()
+	}
+
 	return h, nil
 }

@@ -198,7 +247,6 @@ func (h *WebhookNotifier) isDuplicate(email string) bool {
 	}
 	ttl := time.Duration(h.deduplication) * time.Second
 	now := time.Now()
-	h.maybeSweep(now, ttl)
 	if v, loaded := h.seen.LoadOrStore(email, now); loaded {
 		if now.Sub(v.(time.Time)) < ttl {
 			return true
@@ -208,23 +256,27 @@ func (h *WebhookNotifier) isDuplicate(email string) bool {
 	return false
 }

-func (h *WebhookNotifier) maybeSweep(now time.Time, ttl time.Duration) {
-	last := h.lastSweep.Load()
-	if now.UnixNano()-last < int64(ttl) {
-		return
-	}
-	if !h.lastSweep.CompareAndSwap(last, now.UnixNano()) {
-		return // another goroutine did the sweep
-	}
-	h.seen.Range(func(key, value any) bool {
-		if now.Sub(value.(time.Time)) >= ttl {
-			h.seen.Delete(key)
+func (h *WebhookNotifier) cleanupLoop() {
+	defer h.wg.Done()
+	ttl := time.Duration(h.deduplication) * time.Second
+	ticker := time.NewTicker(ttl)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-h.done:
+			return
+		case <-ticker.C:
+			now := time.Now()
+			h.seen.Range(func(key, value any) bool {
+				if now.Sub(value.(time.Time)) >= ttl {
+					h.seen.Delete(key)
+				}
+				return true
+			})
 		}
-		return true
-	})
+	}
 }

-// Only need to call if the Notifier is really used, otherwise GC can clean it
 func (h *WebhookNotifier) Close() error {
 	h.closeOnce.Do(func() {
 		close(h.done)
@@ -48,20 +48,6 @@ func (m *Manager) RegisterCounter(name string) (stats.Counter, error) {
 	return c, nil
 }

-// GetOrRegisterCounter implements stats.Manager.
-func (m *Manager) GetOrRegisterCounter(name string) (stats.Counter, error) {
-	m.access.Lock()
-	defer m.access.Unlock()
-
-	if c, found := m.counters[name]; found {
-		return c, nil
-	}
-	errors.LogDebug(context.Background(), "create new counter ", name)
-	c := new(Counter)
-	m.counters[name] = c
-	return c, nil
-}
-
 // UnregisterCounter implements stats.Manager.
 func (m *Manager) UnregisterCounter(name string) error {
 	m.access.Lock()
@@ -111,20 +97,6 @@ func (m *Manager) RegisterOnlineMap(name string) (stats.OnlineMap, error) {
 	return om, nil
 }

-// GetOrRegisterOnlineMap implements stats.Manager.
-func (m *Manager) GetOrRegisterOnlineMap(name string) (stats.OnlineMap, error) {
-	m.access.Lock()
-	defer m.access.Unlock()
-
-	if om, found := m.onlineMaps[name]; found {
-		return om, nil
-	}
-	errors.LogDebug(context.Background(), "create new OnlineMap ", name)
-	om := NewOnlineMap()
-	m.onlineMaps[name] = om
-	return om, nil
-}
-
 // UnregisterOnlineMap implements stats.Manager.
 func (m *Manager) UnregisterOnlineMap(name string) error {
 	m.access.Lock()
@@ -177,26 +149,6 @@ func (m *Manager) RegisterChannel(name string) (stats.Channel, error) {
 	return c, nil
 }

-// GetOrRegisterChannel implements stats.Manager.
-func (m *Manager) GetOrRegisterChannel(name string) (stats.Channel, error) {
-	m.access.Lock()
-	defer m.access.Unlock()
-
-	if c, found := m.channels[name]; found {
-		return c, nil
-	}
-	errors.LogDebug(context.Background(), "create new channel ", name)
-	c := NewChannel(&ChannelConfig{BufferSize: 64, Blocking: false})
-	if m.running {
-		// Start before publishing so no goroutine can observe an unstarted channel.
-		if err := c.Start(); err != nil {
-			return nil, err
-		}
-	}
-	m.channels[name] = c
-	return c, nil
-}
-
 // UnregisterChannel implements stats.Manager.
 func (m *Manager) UnregisterChannel(name string) error {
 	m.access.Lock()
@@ -11,7 +11,7 @@ import (
 )

 func TestInterface(t *testing.T) {
-	_ = stats.Manager(new(Manager))
+	_ = (stats.Manager)(new(Manager))
 }

 func TestStatsChannelRunnable(t *testing.T) {
@@ -2,11 +2,10 @@ package version

 import (
 	"context"
-	"strconv"
-	"strings"
-
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
+	"strconv"
+	"strings"
 )

 type Version struct {
@@ -122,7 +122,7 @@ func NewReader(reader io.Reader) Reader {
 	}

 	_, isFile := reader.(*os.File)
-	if !isFile && useReadV() {
+	if !isFile && useReadv {
 		if sc, ok := reader.(syscall.Conn); ok {
 			rawConn, err := sc.SyscallConn()
 			if err != nil {
@@ -38,8 +38,8 @@ func MergeMulti(dest MultiBuffer, src MultiBuffer) (MultiBuffer, MultiBuffer) {
 // MergeBytes merges the given bytes into MultiBuffer and return the new address of the merged MultiBuffer.
 func MergeBytes(dest MultiBuffer, src []byte) MultiBuffer {
 	n := len(dest)
-	if n > 0 && !dest[n-1].IsFull() {
-		nBytes, _ := dest[n-1].Write(src)
+	if n > 0 && !(dest)[n-1].IsFull() {
+		nBytes, _ := (dest)[n-1].Write(src)
 		src = src[nBytes:]
 	}

@@ -121,11 +121,11 @@ func TestPacketReader_ReadMultiBuffer(t *testing.T) {
 }

 func TestReaderInterface(t *testing.T) {
-	_ = io.Reader(new(ReadVReader))
-	_ = Reader(new(ReadVReader))
+	_ = (io.Reader)(new(ReadVReader))
+	_ = (Reader)(new(ReadVReader))

-	_ = Reader(new(BufferedReader))
-	_ = io.Reader(new(BufferedReader))
-	_ = io.ByteReader(new(BufferedReader))
-	_ = io.WriterTo(new(BufferedReader))
+	_ = (Reader)(new(BufferedReader))
+	_ = (io.Reader)(new(BufferedReader))
+	_ = (io.ByteReader)(new(BufferedReader))
+	_ = (io.WriterTo)(new(BufferedReader))
 }
@@ -19,7 +19,7 @@ func (r *posixReader) Init(bs []*Buffer) {
 	}
 	for idx, b := range bs {
 		iovecs = append(iovecs, syscall.Iovec{
-			Base: &b.v[0],
+			Base: &(b.v[0]),
 		})
 		iovecs[idx].SetLen(int(Size))
 	}
@@ -5,7 +5,6 @@ package buf

 import (
 	"io"
-	"sync/atomic"
 	"syscall"

 	"github.com/xtls/xray-core/common/platform"
@@ -144,24 +143,13 @@ func (r *ReadVReader) ReadMultiBuffer() (MultiBuffer, error) {
 	return mb, nil
 }

-var useReadv atomic.Bool
-
-func useReadV() bool {
-	return useReadv.Load()
-}
-
-func reloadEnvSettings() error {
-	const defaultFlagValue = "NOT_DEFINED_AT_ALL"
-	value := platform.NewEnvFlag(platform.UseReadV).GetValue(func() string { return defaultFlagValue })
-	enabled := false
-	switch value {
-	case defaultFlagValue, "auto", "enable":
-		enabled = true
-	}
-	useReadv.Store(enabled)
-	return nil
-}
+var useReadv bool

 func init() {
-	platform.RegisterEnvReload(reloadEnvSettings)
+	const defaultFlagValue = "NOT_DEFINED_AT_ALL"
+	value := platform.NewEnvFlag(platform.UseReadV).GetValue(func() string { return defaultFlagValue })
+	switch value {
+	case defaultFlagValue, "auto", "enable":
+		useReadv = true
+	}
 }
@@ -10,9 +10,7 @@ import (
 	"github.com/xtls/xray-core/features/stats"
 )

-func useReadV() bool {
-	return false
-}
+const useReadv = false

 func NewReadVReader(reader io.Reader, rawConn syscall.RawConn, counter stats.Counter) Reader {
 	panic("not implemented")
@@ -5,8 +5,7 @@ import (
 )

 type windowsReader struct {
-	bufs  []syscall.WSABuf
-	ready bool
+	bufs []syscall.WSABuf
 }

 func (r *windowsReader) Init(bs []*Buffer) {
@@ -16,7 +15,6 @@ func (r *windowsReader) Init(bs []*Buffer) {
 	for _, b := range bs {
 		r.bufs = append(r.bufs, syscall.WSABuf{Len: uint32(Size), Buf: &b.v[0]})
 	}
-	r.ready = false
 }

 func (r *windowsReader) Clear() {
@@ -27,14 +25,6 @@ func (r *windowsReader) Clear() {
 }

 func (r *windowsReader) Read(fd uintptr) int32 {
-	// On the first invocation, we return -1 to indicate "not ready"
-	// to make rawConn.Read wait for readability using the runtime's own mechanism
-	// because syscall.WSARecv() is a blocking call when used with nil OVERLAPPED
-	if !r.ready {
-		r.ready = true
-		return -1
-	}
-
 	var nBytes uint32
 	var flags uint32
 	err := syscall.WSARecv(syscall.Handle(fd), &r.bufs[0], uint32(len(r.bufs)), &nBytes, &flags, nil, nil)
@@ -118,9 +118,7 @@ func (w *BufferedWriter) Write(b []byte) (int, error) {

 		nBytes, err := w.buffer.Write(b)
 		totalBytes += nBytes
-
-		// ErrBufferFull means a partial write, so flush below and continue
-		if err != nil && err != ErrBufferFull {
+		if err != nil {
 			return totalBytes, err
 		}
 		if !w.buffered || w.buffer.IsFull() {
@@ -10,12 +10,12 @@ import (

 // [,)
 func RandBetween(from int64, to int64) int64 {
+	if from == to {
+		return from
+	}
 	if from > to {
 		from, to = to, from
 	}
-	if d := to - from; d == 0 || d == 1 {
-		return from
-	}
 	bigInt, _ := rand.Int(rand.Reader, big.NewInt(to-from))
 	return from + bigInt.Int64()
 }
@@ -1,49 +0,0 @@
-package geodata
-
-import (
-	"sync"
-
-	"github.com/xtls/xray-core/common"
-)
-
-var privateIPMatcher = sync.OnceValue(func() IPMatcher {
-	return common.Must2(IPReg.BuildIPMatcher(common.Must2(ParseIPRules([]string{
-		"0.0.0.0/8",
-		"10.0.0.0/8",
-		"100.64.0.0/10",
-		"127.0.0.0/8",
-		"169.254.0.0/16",
-		"172.16.0.0/12",
-		"192.0.0.0/24",
-		"192.0.2.0/24",
-		"192.88.99.0/24",
-		"192.168.0.0/16",
-		"198.18.0.0/15",
-		"198.51.100.0/24",
-		"203.0.113.0/24",
-		"224.0.0.0/3",
-		"::/127",
-		"fc00::/7",
-		"fe80::/10",
-		"ff00::/8",
-	}))))
-})
-
-func GetPrivateIPMatcher() IPMatcher { return privateIPMatcher() }
-
-var privateDomainMatcher = sync.OnceValue(func() DomainMatcher {
-	return common.Must2(DomainReg.BuildDomainMatcher(common.Must2(ParseDomainRules([]string{
-		"lan",
-		"localdomain",
-		"example",
-		"invalid",
-		"localhost",
-		"test",
-		"local",
-		"home.arpa",
-		"internal",
-		"regexp:^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$", // Dotless domains
-	}, Domain_Domain))))
-})
-
-func GetPrivateDomainMatcher() DomainMatcher { return privateDomainMatcher() }
@@ -8,7 +8,6 @@ import (

 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/geodata/strmatcher"
-	"github.com/xtls/xray-core/common/utils"
 )

 type DomainMatcher interface {
@@ -26,7 +25,7 @@ type DomainMatcherFactory interface {

 type MphDomainMatcherFactory struct {
 	sync.Mutex
-	shared *utils.WeakCacheMap[string, strmatcher.MphValueMatcher]
+	shared map[string]strmatcher.MatcherGroup // TODO: cleanup
 }

 func buildDomainRulesKey(rules []*DomainRule) string {
@@ -66,7 +65,7 @@ func (f *MphDomainMatcherFactory) BuildMatcher(rules []*DomainRule) (DomainMatch
 	if key != "" {
 		f.Lock()
 		defer f.Unlock()
-		if g, ok := f.shared.Load(key); ok {
+		if g := f.shared[key]; g != nil {
 			errors.LogDebug(context.Background(), "geodata mph domain matcher cache HIT for ", len(rules), " rules")
 			return g, nil
 		}
@@ -103,14 +102,14 @@ func (f *MphDomainMatcherFactory) BuildMatcher(rules []*DomainRule) (DomainMatch
 		return nil, err
 	}
 	if key != "" {
-		f.shared.Store(key, g)
+		f.shared[key] = g
 	}
 	return g, nil
 }

 type CompactDomainMatcherFactory struct {
 	sync.Mutex
-	shared *utils.WeakCacheMap[string, strmatcher.LinearAnyMatcher]
+	shared map[string]strmatcher.MatcherSet // TODO: cleanup
 }

 func (f *CompactDomainMatcherFactory) getOrCreateFrom(rule *GeoSiteRule) (strmatcher.MatcherSet, error) {
@@ -119,7 +118,7 @@ func (f *CompactDomainMatcherFactory) getOrCreateFrom(rule *GeoSiteRule) (strmat
 	f.Lock()
 	defer f.Unlock()

-	if s, ok := f.shared.Load(key); ok {
+	if s := f.shared[key]; s != nil {
 		errors.LogDebug(context.Background(), "geodata geosite matcher cache HIT ", key)
 		return s, nil
 	}
@@ -139,7 +138,7 @@ func (f *CompactDomainMatcherFactory) getOrCreateFrom(rule *GeoSiteRule) (strmat
 		}
 		s.Add(m)
 	}
-	f.shared.Store(key, s)
+	f.shared[key] = s
 	return s, err
 }

@@ -220,7 +219,7 @@ func parseDomain(d *Domain) (strmatcher.Matcher, error) {
 	case Domain_Regex:
 		return strmatcher.Regex.New(d.Value)
 	case Domain_Domain:
-		return strmatcher.Domain.New(strings.ToLower(d.Value))
+		return strmatcher.Domain.New(d.Value)
 	case Domain_Full:
 		return strmatcher.Full.New(strings.ToLower(d.Value))
 	default:
@@ -231,8 +230,8 @@ func parseDomain(d *Domain) (strmatcher.Matcher, error) {
 func newDomainMatcherFactory() DomainMatcherFactory {
 	switch runtime.GOOS {
 	case "ios", "android":
-		return &CompactDomainMatcherFactory{shared: utils.NewWeakCacheMap[string, strmatcher.LinearAnyMatcher]()}
+		return &CompactDomainMatcherFactory{shared: make(map[string]strmatcher.MatcherSet)}
 	default:
-		return &MphDomainMatcherFactory{shared: utils.NewWeakCacheMap[string, strmatcher.MphValueMatcher]()}
+		return &MphDomainMatcherFactory{shared: make(map[string]strmatcher.MatcherGroup)}
 	}
 }
@@ -7,11 +7,10 @@ import (
 	"testing"

 	"github.com/xtls/xray-core/common/geodata/strmatcher"
-	"github.com/xtls/xray-core/common/utils"
 )

 func TestCompactDomainMatcher_PreservesCustomRuleIndices(t *testing.T) {
-	factory := &CompactDomainMatcherFactory{shared: utils.NewWeakCacheMap[string, strmatcher.LinearAnyMatcher]()}
+	factory := &CompactDomainMatcherFactory{shared: make(map[string]strmatcher.MatcherSet)}
 	matcher, err := factory.BuildMatcher([]*DomainRule{
 		{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Full, Value: "example.com"}}},
 		{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Domain, Value: "example.com"}}},
@@ -32,7 +31,7 @@ func TestCompactDomainMatcher_PreservesCustomRuleIndices(t *testing.T) {
 func TestCompactDomainMatcher_PreservesMixedRuleIndices(t *testing.T) {
 	t.Setenv("xray.location.asset", filepath.Join("..", "..", "resources"))

-	factory := &CompactDomainMatcherFactory{shared: utils.NewWeakCacheMap[string, strmatcher.LinearAnyMatcher]()}
+	factory := &CompactDomainMatcherFactory{shared: make(map[string]strmatcher.MatcherSet)}
 	matcher, err := factory.BuildMatcher([]*DomainRule{
 		{Value: &DomainRule_Geosite{Geosite: &GeoSiteRule{File: DefaultGeoSiteDat, Code: "CN"}}},
 		{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Full, Value: "163.com"}}},
@@ -51,11 +50,10 @@ func TestCompactDomainMatcher_PreservesMixedRuleIndices(t *testing.T) {
 }

 func TestMphDomainMatcher_MatchReturnsDetachedSlice(t *testing.T) {
-	matcher, err := (&MphDomainMatcherFactory{shared: utils.NewWeakCacheMap[string, strmatcher.MphValueMatcher]()}).
-		BuildMatcher([]*DomainRule{
-			{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Full, Value: "example.com"}}},
-			{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Domain, Value: "example.com"}}},
-		})
+	matcher, err := (&MphDomainMatcherFactory{shared: make(map[string]strmatcher.MatcherGroup)}).BuildMatcher([]*DomainRule{
+		{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Full, Value: "example.com"}}},
+		{Value: &DomainRule_Custom{Custom: &Domain{Type: Domain_Domain, Value: "example.com"}}},
+	})
 	if err != nil {
 		t.Fatalf("BuildMatcher() failed: %v", err)
 	}
@@ -6,14 +6,12 @@ import (
 	"sync/atomic"

 	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/utils"
-	"github.com/xtls/xray-core/common/uuid"
 )

 type DomainRegistry struct {
 	mu       sync.Mutex
 	factory  DomainMatcherFactory
-	matchers *utils.WeakCacheMap[uuid.UUID, DynamicDomainMatcher]
+	matchers []*DynamicDomainMatcher
 }

 func (r *DomainRegistry) BuildDomainMatcher(rules []*DomainRule) (DomainMatcher, error) {
@@ -26,7 +24,7 @@ func (r *DomainRegistry) BuildDomainMatcher(rules []*DomainRule) (DomainMatcher,
 	}

 	d := NewDynamicDomainMatcher(rules, m)
-	r.matchers.Store(uuid.New(), d)
+	r.matchers = append(r.matchers, d)
 	return d, nil
 }

@@ -34,20 +32,15 @@ func (r *DomainRegistry) Reload() error {
 	r.mu.Lock()
 	defer r.mu.Unlock()

-	var matchers []*DynamicDomainMatcher
-	r.matchers.Range(func(_ uuid.UUID, matcher *DynamicDomainMatcher) bool {
-		matchers = append(matchers, matcher)
-		return true
-	})
-	errors.LogInfo(context.Background(), "reloading GeoSite data for ", len(matchers), " domain matcher(s)")
+	errors.LogInfo(context.Background(), "reloading GeoSite data for ", len(r.matchers), " domain matcher(s)")

 	factory := newDomainMatcherFactory()
 	type reloadEntry struct {
 		dynamic *DynamicDomainMatcher
 		matcher DomainMatcher
 	}
-	reloaded := make([]reloadEntry, len(matchers))
-	for i, d := range matchers {
+	reloaded := make([]reloadEntry, len(r.matchers))
+	for i, d := range r.matchers {
 		m, err := factory.BuildMatcher(d.rules)
 		if err != nil {
 			errors.LogErrorInner(context.Background(), err, "failed to reload GeoSite data for domain matcher ", i)
@@ -59,14 +52,13 @@ func (r *DomainRegistry) Reload() error {
 		entry.dynamic.Reload(entry.matcher)
 	}
 	r.factory = factory
-	errors.LogInfo(context.Background(), "reloaded GeoSite data for ", len(matchers), " domain matcher(s)")
+	errors.LogInfo(context.Background(), "reloaded GeoSite data for ", len(r.matchers), " domain matcher(s)")
 	return nil
 }

 func newDomainRegistry() *DomainRegistry {
 	return &DomainRegistry{
-		factory:  newDomainMatcherFactory(),
-		matchers: utils.NewWeakCacheMap[uuid.UUID, DynamicDomainMatcher](),
+		factory: newDomainMatcherFactory(),
 	}
 }

@@ -11,7 +11,6 @@ import (

 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/common/utils"

 	"go4.org/netipx"
 )
@@ -807,7 +806,7 @@ func (mm *HeuristicMultiIPMatcher) SetReverse(reverse bool) {

 type IPSetFactory struct {
 	sync.Mutex
-	shared *utils.WeakCacheMap[string, IPSet]
+	shared map[string]*IPSet // TODO: cleanup
 }

 func (f *IPSetFactory) GetOrCreateFromGeoIPRules(rules []*GeoIPRule) (*IPSet, error) {
@@ -816,7 +815,7 @@ func (f *IPSetFactory) GetOrCreateFromGeoIPRules(rules []*GeoIPRule) (*IPSet, er
 	f.Lock()
 	defer f.Unlock()

-	if ipset, ok := f.shared.Load(key); ok {
+	if ipset := f.shared[key]; ipset != nil {
 		errors.LogDebug(context.Background(), "geodata geoip matcher cache HIT ", key)
 		return ipset, nil
 	}
@@ -836,7 +835,7 @@ func (f *IPSetFactory) GetOrCreateFromGeoIPRules(rules []*GeoIPRule) (*IPSet, er
 		return nil
 	})
 	if err == nil {
-		f.shared.Store(key, ipset)
+		f.shared[key] = ipset
 	}
 	return ipset, err
 }
@@ -1019,5 +1018,5 @@ func buildOptimizedIPMatcher(f *IPSetFactory, rules []*IPRule) (IPMatcher, error
 }

 func newIPSetFactory() *IPSetFactory {
-	return &IPSetFactory{shared: utils.NewWeakCacheMap[string, IPSet]()}
+	return &IPSetFactory{shared: make(map[string]*IPSet)}
 }
@@ -315,7 +315,7 @@ func TestIPMatcherAnyMatchAndMatches(t *testing.T) {
 	}

 	if !matcher.AnyMatch([]net.IP{
-		{},
+		net.IP{},
 		ip("1.1.1.1"),
 		ip("8.8.8.8"),
 	}) {
@@ -345,7 +345,7 @@ func TestIPMatcherAnyMatchAndMatches(t *testing.T) {

 	if matcher.Matches([]net.IP{
 		ip("8.8.8.8"),
-		{},
+		net.IP{},
 	}) {
 		t.Fatal("expect Matches to be false when any IP is invalid")
 	}
@@ -362,7 +362,7 @@ func TestIPMatcherFilterIPs(t *testing.T) {
 	}

 	matched, unmatched := matcher.FilterIPs([]net.IP{
-		{},
+		net.IP{},
 		ip("8.8.8.8"),
 		ip("91.108.255.254"),
 		ip("1.1.1.1"),
@@ -7,27 +7,25 @@ import (

 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/common/utils"
-	"github.com/xtls/xray-core/common/uuid"
 )

 type IPRegistry struct {
-	mu       sync.Mutex
-	factory  *IPSetFactory
-	matchers *utils.WeakCacheMap[uuid.UUID, DynamicIPMatcher]
+	mu           sync.Mutex
+	ipsetFactory *IPSetFactory
+	matchers     []*DynamicIPMatcher
 }

 func (r *IPRegistry) BuildIPMatcher(rules []*IPRule) (IPMatcher, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()

-	m, err := buildOptimizedIPMatcher(r.factory, rules)
+	m, err := buildOptimizedIPMatcher(r.ipsetFactory, rules)
 	if err != nil {
 		return nil, err
 	}

 	d := NewDynamicIPMatcher(rules, m)
-	r.matchers.Store(uuid.New(), d)
+	r.matchers = append(r.matchers, d)
 	return d, nil
 }

@@ -35,20 +33,15 @@ func (r *IPRegistry) Reload() error {
 	r.mu.Lock()
 	defer r.mu.Unlock()

-	var matchers []*DynamicIPMatcher
-	r.matchers.Range(func(_ uuid.UUID, matcher *DynamicIPMatcher) bool {
-		matchers = append(matchers, matcher)
-		return true
-	})
-	errors.LogInfo(context.Background(), "reloading GeoIP data for ", len(matchers), " IP matcher(s)")
+	errors.LogInfo(context.Background(), "reloading GeoIP data for ", len(r.matchers), " IP matcher(s)")

 	factory := newIPSetFactory()
 	type reloadEntry struct {
 		dynamic *DynamicIPMatcher
 		matcher IPMatcher
 	}
-	reloaded := make([]reloadEntry, len(matchers))
-	for i, d := range matchers {
+	reloaded := make([]reloadEntry, len(r.matchers))
+	for i, d := range r.matchers {
 		m, err := buildOptimizedIPMatcher(factory, d.rules)
 		if err != nil {
 			errors.LogErrorInner(context.Background(), err, "failed to reload GeoIP data for IP matcher ", i)
@@ -59,15 +52,14 @@ func (r *IPRegistry) Reload() error {
 	for _, entry := range reloaded {
 		entry.dynamic.Reload(entry.matcher)
 	}
-	r.factory = factory
-	errors.LogInfo(context.Background(), "reloaded GeoIP data for ", len(matchers), " IP matcher(s)")
+	r.ipsetFactory = factory
+	errors.LogInfo(context.Background(), "reloaded GeoIP data for ", len(r.matchers), " IP matcher(s)")
 	return nil
 }

 func newIPRegistry() *IPRegistry {
 	return &IPRegistry{
-		factory:  newIPSetFactory(),
-		matchers: utils.NewWeakCacheMap[uuid.UUID, DynamicIPMatcher](),
+		ipsetFactory: newIPSetFactory(),
 	}
 }

@@ -1,58 +0,0 @@
-package geodata
-
-import (
-	lua "github.com/yuin/gopher-lua"
-	luar "layeh.com/gopher-luar"
-)
-
-// RegisterLua makes xray.geodata available to require in an LState.
-func RegisterLua(L *lua.LState) {
-	L.PreloadModule("xray.geodata", func(L *lua.LState) int {
-		module := L.NewTable()
-
-		module.RawSetString("BuildDomainMatcher", L.NewFunction(func(L *lua.LState) int {
-			parsed, err := ParseDomainRules(luaRules(L), Domain_Domain)
-			if err != nil {
-				L.RaiseError("%v", err)
-				return 0
-			}
-			matcher, err := DomainReg.BuildDomainMatcher(parsed)
-			if err != nil {
-				L.RaiseError("%v", err)
-				return 0
-			}
-			L.Push(luar.New(L, matcher))
-			return 1
-		}))
-
-		module.RawSetString("BuildIPMatcher", L.NewFunction(func(L *lua.LState) int {
-			parsed, err := ParseIPRules(luaRules(L))
-			if err != nil {
-				L.RaiseError("%v", err)
-				return 0
-			}
-			matcher, err := IPReg.BuildIPMatcher(parsed)
-			if err != nil {
-				L.RaiseError("%v", err)
-				return 0
-			}
-			L.Push(luar.New(L, matcher))
-			return 1
-		}))
-		L.Push(module)
-		return 1
-	})
-}
-
-func luaRules(L *lua.LState) []string {
-	rules := make([]string, L.GetTop())
-	for i := range rules {
-		value, ok := L.Get(i + 1).(lua.LString)
-		if !ok {
-			L.RaiseError("geodata rules must be strings")
-			return nil
-		}
-		rules[i] = string(value)
-	}
-	return rules
-}
@@ -1,66 +0,0 @@
-package geodata
-
-import (
-	"testing"
-
-	"github.com/xtls/xray-core/common/net"
-	lua "github.com/yuin/gopher-lua"
-)
-
-func TestLuaIPMatcher(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	RegisterLua(L)
-	ip := L.NewUserData()
-	ip.Value = net.ParseIP("127.0.0.1")
-	L.SetGlobal("ip", ip)
-	ips := L.NewUserData()
-	ips.Value = []net.IP{ip.Value.(net.IP), net.ParseIP("8.8.8.8")}
-	L.SetGlobal("ips", ips)
-	if err := L.DoString(`
-		local matcher = require("xray.geodata").BuildIPMatcher("127.0.0.0/8", "::1")
-		assert(matcher:Match(ip))
-		assert(matcher:AnyMatch(ips))
-		assert(not matcher:Matches(ips))
-		local matched, unmatched = matcher:FilterIPs(ips)
-		assert(type(matched) == "userdata" and type(unmatched) == "userdata")
-		assert(#matched == 1 and #unmatched == 1)
-	`); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestLuaDomainMatcher(t *testing.T) {
-	L := lua.NewState()
-	defer L.Close()
-	RegisterLua(L)
-	if err := L.DoString(`
-		local matcher = require("xray.geodata").BuildDomainMatcher("example.com", "full:other.com")
-		assert(matcher:MatchAny("example.com"))
-		assert(matcher:MatchAny("www.example.com"))
-		assert(matcher:MatchAny("other.com"))
-		assert(not matcher:MatchAny("www.other.com"))
-		assert(#(matcher:Match("www.example.com")) == 1)
-	`); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestLuaMatchersRejectInvalidRules(t *testing.T) {
-	for _, tc := range []struct {
-		name   string
-		script string
-	}{
-		{"IP rule", `require("xray.geodata").BuildIPMatcher("not-an-ip")`},
-		{"non-string domain rule", `require("xray.geodata").BuildDomainMatcher("example.com", true)`},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			L := lua.NewState()
-			defer L.Close()
-			RegisterLua(L)
-			if err := L.DoString(tc.script); err == nil {
-				t.Fatal("invalid geodata rule was accepted")
-			}
-		})
-	}
-}
@@ -138,7 +138,7 @@ func ParseDomainRule(r string, defaultType Domain_Type) (*DomainRule, error) {
 	}

 	prefix := 0
-	for _, ext := range [...]string{"ext:", "ext-domain:", "ext-site:"} {
+	for _, ext := range [...]string{"ext:", "ext-domain:"} {
 		if strings.HasPrefix(r, ext) {
 			prefix = len(ext)
 			break
@@ -167,7 +167,7 @@ func ParseDomainRules(rules []string, defaultType Domain_Type) ([]*DomainRule, e
 		}

 		prefix := 0
-		for _, ext := range [...]string{"ext:", "ext-domain:", "ext-site:"} {
+		for _, ext := range [...]string{"ext:", "ext-domain:"} {
 			if strings.HasPrefix(r, ext) {
 				prefix = len(ext)
 				break
@@ -98,6 +98,7 @@ func (l *generalLogger) run() {
 }

 func (l *generalLogger) Handle(msg Message) {
+
 	select {
 	case l.buffer <- msg:
 	default:
@@ -1,50 +0,0 @@
-package log
-
-import (
-	"path/filepath"
-	"strings"
-
-	lua "github.com/yuin/gopher-lua"
-)
-
-// RegisterLua makes xray.log available to require in an LState.
-func RegisterLua(L *lua.LState) {
-	L.PreloadModule("xray.log", func(L *lua.LState) int {
-		module := L.NewTable()
-		for name, severity := range map[string]Severity{
-			"Debug":   Severity_Debug,
-			"Info":    Severity_Info,
-			"Warning": Severity_Warning,
-			"Error":   Severity_Error,
-		} {
-			module.RawSetString(name, L.NewFunction(func(L *lua.LState) int {
-				var content strings.Builder
-				// Prefix with the calling script's filename.
-				if caller, ok := L.GetStack(1); ok {
-					if _, err := L.GetInfo("S", caller, lua.LNil); err == nil && caller.Source != "" {
-						content.WriteString(filepath.Base(strings.TrimPrefix(caller.Source, "@")))
-						content.WriteString(": ")
-					}
-				}
-				for i := 1; i <= L.GetTop(); i++ {
-					value := L.Get(i)
-					// Use Error() for Go errors in userdata.
-					if ud, ok := value.(*lua.LUserData); ok {
-						if err, ok := ud.Value.(error); ok {
-							content.WriteString(err.Error())
-							continue
-						}
-					}
-					content.WriteString(L.ToStringMeta(value).String())
-				}
-				Record(&GeneralMessage{
-					Severity: severity,
-					Content:  content.String(),
-				})
-				return 0
-			}))
-		}
-		L.Push(module)
-		return 1
-	})
-}
@@ -1,92 +0,0 @@
-package log
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-
-	lua "github.com/yuin/gopher-lua"
-)
-
-type luaLogHandler struct {
-	messages []Message
-}
-
-func (h *luaLogHandler) Handle(msg Message) {
-	h.messages = append(h.messages, msg)
-}
-
-func TestLuaLog(t *testing.T) {
-	logHandler.RLock()
-	previous := logHandler.Handler
-	logHandler.RUnlock()
-	t.Cleanup(func() { RegisterHandler(previous) })
-	handler := &luaLogHandler{}
-	RegisterHandler(handler)
-
-	L := lua.NewState()
-	defer L.Close()
-	RegisterLua(L)
-	nativeError := L.NewUserData()
-	nativeError.Value = fmt.Errorf("lookup failed: %w", errors.New("upstream timeout"))
-	L.SetGlobal("nativeError", nativeError)
-	path := filepath.Join(t.TempDir(), "logging.lua")
-	if err := os.WriteFile(path, []byte(`
-		local log = require("xray.log")
-		assert(log == require("xray.log"))
-		log.Debug("query: ", "example.com")
-		log.Info("count=", 42, ", enabled=", true, ", value=", nil)
-		log.Warning(setmetatable({}, {
-			__tostring = function() return "fallback" end
-		}))
-		assert(select("#", log.Error("failed")) == 0)
-		log.Error("DNS failed: ", nativeError)
-		log.Warning(nativeError)
-		local ok, err = pcall(function() error("Lua failure", 0) end)
-		assert(not ok)
-		log.Error(err)
-		function logHook()
-			log.Info("hook")
-		end
-	`), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := L.DoFile(path); err != nil {
-		t.Fatal(err)
-	}
-	if err := L.DoString(`
-		logHook()
-		require("xray.log").Info("anonymous")
-	`); err != nil {
-		t.Fatal(err)
-	}
-
-	want := []struct {
-		severity Severity
-		message  string
-	}{
-		{Severity_Debug, "[Debug] logging.lua: query: example.com"},
-		{Severity_Info, "[Info] logging.lua: count=42, enabled=true, value=nil"},
-		{Severity_Warning, "[Warning] logging.lua: fallback"},
-		{Severity_Error, "[Error] logging.lua: failed"},
-		{Severity_Error, "[Error] logging.lua: DNS failed: lookup failed: upstream timeout"},
-		{Severity_Warning, "[Warning] logging.lua: lookup failed: upstream timeout"},
-		{Severity_Error, "[Error] logging.lua: Lua failure"},
-		{Severity_Info, "[Info] logging.lua: hook"},
-		{Severity_Info, "[Info] <string>: anonymous"},
-	}
-	if len(handler.messages) != len(want) {
-		t.Fatalf("logged %d messages, want %d", len(handler.messages), len(want))
-	}
-	for i, expected := range want {
-		msg, ok := handler.messages[i].(*GeneralMessage)
-		if !ok {
-			t.Fatalf("message %d has type %T, want *GeneralMessage", i, handler.messages[i])
-		}
-		if msg.Severity != expected.severity || msg.String() != expected.message {
-			t.Errorf("message %d = %q with severity %v, want %q with severity %v", i, msg.String(), msg.Severity, expected.message, expected.severity)
-		}
-	}
-}
@@ -1,138 +0,0 @@
-package lua
-
-import (
-	"context"
-	"errors"
-	"sync"
-
-	glua "github.com/yuin/gopher-lua"
-)
-
-const maxIdleStates = 16
-
-// LStateFactory must initialize a state fully and observe ctx while doing so.
-// The pool owns any non-nil state it returns, even when it also returns an error.
-type LStateFactory func(ctx context.Context) (*glua.LState, error)
-
-// Pool lends each state to one caller at a time. It grows on contention and
-// keeps up to maxIdleStates idle states until Close. Callers decide whether a
-// state is reusable.
-type Pool struct {
-	ctx    context.Context
-	cancel context.CancelFunc
-
-	factory LStateFactory
-	idle    []*glua.LState
-
-	mu     sync.Mutex
-	active sync.WaitGroup
-	closed bool
-}
-
-// NewPool initializes one state before returning, so top-level errors surface at startup.
-func NewPool(ctx context.Context, factory LStateFactory) (*Pool, error) {
-	poolCtx, cancel := context.WithCancel(ctx)
-
-	// Create one state now to catch factory errors at startup.
-	state, err := factory(poolCtx)
-	if err != nil {
-		cancel()
-		if state != nil {
-			state.Close()
-		}
-		return nil, err
-	}
-	if state == nil {
-		cancel()
-		return nil, errors.New("Lua state factory returned nil")
-	}
-	if err := poolCtx.Err(); err != nil {
-		state.Close()
-		cancel()
-		return nil, err
-	}
-
-	return &Pool{ctx: poolCtx, cancel: cancel, factory: factory, idle: []*glua.LState{state}}, nil
-}
-
-// Context is cancelled by Close. Query contexts should derive from it.
-func (p *Pool) Context() context.Context {
-	return p.ctx
-}
-
-// Acquire returns an initialized exclusive state, growing the pool if necessary.
-func (p *Pool) Acquire() (*glua.LState, error) {
-	p.mu.Lock()
-	if p.closed || p.ctx.Err() != nil {
-		p.mu.Unlock()
-		return nil, p.ctx.Err()
-	}
-
-	p.active.Add(1)
-
-	n := len(p.idle)
-	if n != 0 {
-		state := p.idle[n-1]
-		p.idle = p.idle[:n-1]
-		p.mu.Unlock()
-		return state, nil
-	}
-	p.mu.Unlock()
-
-	// TODO: Limit the total number of states. When the limit is reached, wait
-	// for a Release instead of creating another state; allow the wait to be
-	// cancelled by the caller or by Close.
-	state, err := p.factory(p.ctx)
-	if err == nil && state == nil {
-		err = errors.New("Lua state factory returned nil")
-	}
-	if err != nil {
-		if state != nil {
-			state.Close()
-		}
-		p.active.Done()
-		return nil, err
-	}
-	if err := p.ctx.Err(); err != nil {
-		state.Close()
-		p.active.Done()
-		return nil, err
-	}
-
-	return state, nil
-}
-
-// Release returns a healthy state to the pool and closes a failed or cancelled one.
-func (p *Pool) Release(state *glua.LState, reusable bool) {
-	if reusable {
-		p.mu.Lock()
-		if !p.closed && p.ctx.Err() == nil && len(p.idle) < maxIdleStates {
-			p.idle = append(p.idle, state)
-		} else {
-			reusable = false
-		}
-		p.mu.Unlock()
-	}
-
-	if !reusable {
-		state.Close()
-	}
-
-	p.active.Done()
-}
-
-// Close cancels active work, closes idle states, and waits for borrowed states.
-func (p *Pool) Close() {
-	p.mu.Lock()
-	if !p.closed {
-		p.closed = true
-		p.cancel()
-		for _, state := range p.idle {
-			state.Close()
-		}
-		p.idle = nil
-	}
-	p.mu.Unlock()
-
-	p.active.Wait()
-}
@@ -1,197 +0,0 @@
-package lua
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	glua "github.com/yuin/gopher-lua"
-)
-
-func TestPoolFactoryFailureClosesReturnedState(t *testing.T) {
-	failure := errors.New("factory failed")
-	state := glua.NewState()
-	_, err := NewPool(context.Background(), func(context.Context) (*glua.LState, error) {
-		return state, failure
-	})
-	if !errors.Is(err, failure) || !state.IsClosed() {
-		t.Fatalf("NewPool error = %v, state closed = %t", err, state.IsClosed())
-	}
-
-	var failedState *glua.LState
-	calls := 0
-	pool, err := NewPool(context.Background(), func(context.Context) (*glua.LState, error) {
-		calls++
-		if calls == 1 {
-			return glua.NewState(), nil
-		}
-		failedState = glua.NewState()
-		return failedState, failure
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer pool.Close()
-	borrowed, err := pool.Acquire()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer pool.Release(borrowed, true)
-	_, err = pool.Acquire()
-	if !errors.Is(err, failure) || !failedState.IsClosed() {
-		t.Fatalf("Acquire error = %v, state closed = %t", err, failedState.IsClosed())
-	}
-}
-
-func TestPoolReusesStatesAndLimitsIdle(t *testing.T) {
-	created := 0
-	pool, err := NewPool(context.Background(), func(context.Context) (*glua.LState, error) {
-		created++
-		return glua.NewState(), nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer pool.Close()
-
-	states := make([]*glua.LState, maxIdleStates+3)
-	for i := range states {
-		states[i], err = pool.Acquire()
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, state := range states {
-		pool.Release(state, true)
-	}
-	for i, state := range states {
-		if got, want := state.IsClosed(), i >= maxIdleStates; got != want {
-			t.Fatalf("state %d closed = %t, want %t", i, got, want)
-		}
-	}
-	borrowed, err := pool.Acquire()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if created != len(states) {
-		t.Fatalf("Acquire created %d states, want %d", created, len(states))
-	}
-	pool.Release(borrowed, true)
-}
-
-func TestPoolCloseCancelsAndWaitsForBorrowedState(t *testing.T) {
-	pool, err := NewPool(context.Background(), func(context.Context) (*glua.LState, error) {
-		return glua.NewState(), nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	state, err := pool.Acquire()
-	if err != nil {
-		t.Fatal(err)
-	}
-	done := make(chan struct{})
-	go func() {
-		pool.Close()
-		close(done)
-	}()
-	select {
-	case <-pool.Context().Done():
-	case <-time.After(time.Second):
-		pool.Release(state, false)
-		t.Fatal("Close did not cancel the pool context")
-	}
-	select {
-	case <-done:
-		pool.Release(state, false)
-		t.Fatal("Close returned while a state was borrowed")
-	default:
-	}
-	pool.Release(state, true)
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatal("Close did not finish after Release")
-	}
-	if !state.IsClosed() {
-		t.Fatal("borrowed state was not closed")
-	}
-	if _, err := pool.Acquire(); !errors.Is(err, context.Canceled) {
-		t.Fatalf("Acquire after Close = %v, want context.Canceled", err)
-	}
-	pool.Close()
-}
-
-func TestPoolCloseCancelsStateCreation(t *testing.T) {
-	started := make(chan struct{})
-	first := true
-	pool, err := NewPool(context.Background(), func(ctx context.Context) (*glua.LState, error) {
-		if first {
-			first = false
-			return glua.NewState(), nil
-		}
-		close(started)
-		<-ctx.Done()
-		return nil, ctx.Err()
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	borrowed, err := pool.Acquire()
-	if err != nil {
-		t.Fatal(err)
-	}
-	acquireDone := make(chan error, 1)
-	go func() {
-		_, err := pool.Acquire()
-		acquireDone <- err
-	}()
-	<-started
-	closeDone := make(chan struct{})
-	go func() {
-		pool.Close()
-		close(closeDone)
-	}()
-	select {
-	case err := <-acquireDone:
-		if !errors.Is(err, context.Canceled) {
-			t.Fatalf("Acquire during Close = %v, want context.Canceled", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("state creation did not stop after Close")
-	}
-	select {
-	case <-closeDone:
-		pool.Release(borrowed, false)
-		t.Fatal("Close returned while the initial state was borrowed")
-	default:
-	}
-	pool.Release(borrowed, true)
-	select {
-	case <-closeDone:
-	case <-time.After(time.Second):
-		t.Fatal("Close did not finish after Release")
-	}
-}
-
-func BenchmarkPoolAcquireRelease(b *testing.B) {
-	pool, err := NewPool(context.Background(), func(context.Context) (*glua.LState, error) {
-		return glua.NewState(), nil
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer pool.Close()
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		state, err := pool.Acquire()
-		if err != nil {
-			b.Fatal(err)
-		}
-		pool.Release(state, true)
-	}
-	b.StopTimer()
-}
@@ -1,56 +0,0 @@
-// Package lua provides shared GopherLua programs and state management for Xray scripts.
-package lua
-
-import (
-	"bufio"
-	"context"
-	"os"
-
-	glua "github.com/yuin/gopher-lua"
-	"github.com/yuin/gopher-lua/parse"
-)
-
-// Program holds immutable bytecode that can be run by independent LStates.
-type Program struct {
-	proto *glua.FunctionProto
-}
-
-// CompileFile reads and compiles a Lua file once.
-func CompileFile(path string) (*Program, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	chunk, err := parse.Parse(bufio.NewReader(f), path)
-	if err != nil {
-		return nil, err
-	}
-	proto, err := glua.Compile(chunk, path)
-	if err != nil {
-		return nil, err
-	}
-	return &Program{proto: proto}, nil
-}
-
-// NewState creates a VM, makes modules available, and executes the file top level.
-// Module loaders run only when Lua calls require. Each state gets its own globals.
-// The caller owns the returned state.
-func (p *Program) NewState(ctx context.Context, register func(*glua.LState)) (*glua.LState, error) {
-	L := glua.NewState()
-	if register != nil {
-		register(L)
-	}
-	L.SetContext(ctx)
-	L.Push(L.NewFunctionFromProto(p.proto))
-	err := L.PCall(0, 0, nil)
-	L.RemoveContext()
-	if err == nil {
-		err = ctx.Err()
-	}
-	if err != nil {
-		L.Close()
-		return nil, err
-	}
-	return L, nil
-}
@@ -1,55 +0,0 @@
-package lua
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-
-	glua "github.com/yuin/gopher-lua"
-)
-
-func TestProgramStatesAreIndependent(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "state.lua")
-	if err := os.WriteFile(path, []byte("value = (value or 0) + 1"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	program, err := CompileFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	first, err := program.NewState(context.Background(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer first.Close()
-	first.SetGlobal("value", glua.LNumber(42))
-	second, err := program.NewState(context.Background(), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer second.Close()
-	if got := second.GetGlobal("value"); got != glua.LNumber(1) {
-		t.Fatalf("second state value = %v, want 1", got)
-	}
-}
-
-func TestProgramInitializationObservesCancellation(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "loop.lua")
-	if err := os.WriteFile(path, []byte("while true do end"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	program, err := CompileFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	state, err := program.NewState(ctx, nil)
-	if err == nil || state != nil {
-		if state != nil {
-			state.Close()
-		}
-		t.Fatalf("NewState with canceled context = %v, %v; want nil state and error", state, err)
-	}
-}
@@ -1,350 +0,0 @@
-//go:build darwin && !ios
-
-package net
-
-import (
-	"bytes"
-	"net"
-	"net/netip"
-	"path/filepath"
-	"strings"
-	"syscall"
-	"unsafe"
-
-	"golang.org/x/sys/unix"
-
-	"github.com/xtls/xray-core/common/errors"
-)
-
-const (
-	darwinProcPIDListFDs      = 1
-	darwinProcPIDFDSocketInfo = 3
-	darwinProcFDTypeSocket    = 2
-	darwinProcFDInfoSize      = 8
-	darwinSocketFDInfoSize    = 792
-	darwinSocketFDInfoPSIOff  = 24
-	darwinSocketInfoProtoOff  = darwinSocketFDInfoPSIOff + 156
-	darwinSocketInfoFamilyOff = darwinSocketFDInfoPSIOff + 160
-	darwinSocketInfoKindOff   = darwinSocketFDInfoPSIOff + 232
-	darwinSocketInfoInSockOff = darwinSocketFDInfoPSIOff + 240
-	darwinInSockInfoFPortOff  = darwinSocketInfoInSockOff
-	darwinInSockInfoLPortOff  = darwinSocketInfoInSockOff + 4
-	darwinInSockInfoVFlagOff  = darwinSocketInfoInSockOff + 24
-	darwinInSockInfoFAddrOff  = darwinSocketInfoInSockOff + 32
-	darwinInSockInfoLAddrOff  = darwinSocketInfoInSockOff + 48
-	darwinInSockInfoSize      = 80
-	darwinInSockInfoIPv4      = 0x1
-	darwinInSockInfoIPv6      = 0x2
-	darwinSockInfoIN          = 1
-	darwinSockInfoTCP         = 2
-)
-
-type darwinSocketMatchLevel int
-
-const (
-	darwinSocketNoMatch darwinSocketMatchLevel = iota
-	darwinSocketPortMatch
-	darwinSocketRemoteMatch
-	darwinSocketLocalMatch
-	darwinSocketExactMatch
-)
-
-func FindProcess(network, srcIP string, srcPort uint16, destIP string, destPort uint16) (PID int, Name string, AbsolutePath string, err error) {
-	isLocal, err := IsLocal(net.ParseIP(srcIP))
-	if err != nil {
-		return 0, "", "", errors.New("failed to determine if address is local: ", err)
-	}
-	if !isLocal {
-		return 0, "", "", ErrNotLocal
-	}
-	if network != "tcp" && network != "udp" {
-		panic("Unsupported network type for process lookup.")
-	}
-
-	srcAddr, err := netip.ParseAddr(srcIP)
-	if err != nil {
-		return 0, "", "", errors.New("invalid source IP address: ", srcIP)
-	}
-	srcAddr = srcAddr.Unmap()
-
-	var dstAddr netip.Addr
-	hasDstAddr := false
-	if destIP != "" && destPort != 0 {
-		dstAddr, err = netip.ParseAddr(destIP)
-		if err != nil {
-			return 0, "", "", errors.New("invalid destination IP address: ", destIP)
-		}
-		dstAddr = dstAddr.Unmap()
-		hasDstAddr = true
-	}
-
-	processes, err := unix.SysctlKinfoProcSlice("kern.proc.all")
-	if err != nil {
-		return 0, "", "", errors.New("failed to list processes").Base(err)
-	}
-
-	var bestPID int32
-	bestLevel := darwinSocketNoMatch
-	ambiguousBest := false
-
-	for _, process := range processes {
-		pid := process.Proc.P_pid
-		if pid <= 0 {
-			continue
-		}
-
-		matchLevel, err := darwinProcessSocketMatchLevel(pid, network, srcAddr, srcPort, dstAddr, destPort, hasDstAddr)
-		if err != nil || matchLevel == darwinSocketNoMatch {
-			continue
-		}
-		if matchLevel == darwinSocketExactMatch {
-			bestPID = pid
-			bestLevel = matchLevel
-			ambiguousBest = false
-			break
-		}
-		if matchLevel > bestLevel {
-			bestPID = pid
-			bestLevel = matchLevel
-			ambiguousBest = false
-			continue
-		}
-		if matchLevel == bestLevel {
-			ambiguousBest = true
-		}
-	}
-
-	if bestLevel == darwinSocketNoMatch {
-		return 0, "", "", errors.New("process not found for ", network, " connection from ", srcIP, ":", srcPort, " to ", destIP, ":", destPort)
-	}
-	if ambiguousBest {
-		return 0, "", "", errors.New("ambiguous process match for ", network, " connection from ", srcIP, ":", srcPort, " to ", destIP, ":", destPort)
-	}
-
-	absPath, err := darwinProcessPath(bestPID)
-	if err != nil {
-		return 0, "", "", errors.New("could not get process path for PID ", bestPID, ": ", err)
-	}
-
-	absPath = filepath.ToSlash(absPath)
-	return int(bestPID), filepath.Base(absPath), absPath, nil
-}
-
-func darwinProcessSocketMatchLevel(pid int32, network string, srcAddr netip.Addr, srcPort uint16, dstAddr netip.Addr, dstPort uint16, hasDstAddr bool) (darwinSocketMatchLevel, error) {
-	fds, err := darwinProcessFDs(pid)
-	if err != nil {
-		return darwinSocketNoMatch, err
-	}
-
-	bestLevel := darwinSocketNoMatch
-	info := make([]byte, darwinSocketFDInfoSize)
-	for fd := 0; fd+darwinProcFDInfoSize <= len(fds); fd += darwinProcFDInfoSize {
-		fdNumber := int32(darwinReadNativeUint32(fds[fd : fd+4]))
-		fdType := darwinReadNativeUint32(fds[fd+4 : fd+8])
-		if fdType != darwinProcFDTypeSocket {
-			continue
-		}
-
-		n, err := darwinProcPIDFDInfo(pid, fdNumber, darwinProcPIDFDSocketInfo, info)
-		if err != nil || n < darwinSocketInfoInSockOff+darwinInSockInfoSize {
-			continue
-		}
-		level := darwinSocketInfoMatchLevel(info[:n], network, srcAddr, srcPort, dstAddr, dstPort, hasDstAddr)
-		if level == darwinSocketExactMatch {
-			return level, nil
-		}
-		if level > bestLevel {
-			bestLevel = level
-		}
-	}
-
-	return bestLevel, nil
-}
-
-func darwinProcessFDs(pid int32) ([]byte, error) {
-	n, err := darwinProcPIDInfo(pid, darwinProcPIDListFDs, 0, nil)
-	if err != nil {
-		return nil, err
-	}
-	if n <= 0 {
-		return nil, nil
-	}
-
-	buf := make([]byte, n)
-	n, err = darwinProcPIDInfo(pid, darwinProcPIDListFDs, 0, buf)
-	if err != nil {
-		return nil, err
-	}
-	return buf[:n], nil
-}
-
-func darwinSocketInfoMatchLevel(info []byte, network string, srcAddr netip.Addr, srcPort uint16, dstAddr netip.Addr, dstPort uint16, hasDstAddr bool) darwinSocketMatchLevel {
-	protocol := int(darwinReadNativeUint32(info[darwinSocketInfoProtoOff : darwinSocketInfoProtoOff+4]))
-	family := int(darwinReadNativeUint32(info[darwinSocketInfoFamilyOff : darwinSocketInfoFamilyOff+4]))
-	kind := int(darwinReadNativeUint32(info[darwinSocketInfoKindOff : darwinSocketInfoKindOff+4]))
-
-	switch network {
-	case "tcp":
-		if protocol != unix.IPPROTO_TCP || kind != darwinSockInfoTCP {
-			return darwinSocketNoMatch
-		}
-	case "udp":
-		if protocol != unix.IPPROTO_UDP || kind != darwinSockInfoIN {
-			return darwinSocketNoMatch
-		}
-	default:
-		return darwinSocketNoMatch
-	}
-
-	vflag := info[darwinInSockInfoVFlagOff]
-	if srcAddr.Is4() {
-		// Dual-stack sockets expose IPv4-mapped connections as AF_INET6
-		// while marking the endpoint as IPv4 in ini_vflag.
-		if (family != unix.AF_INET && family != unix.AF_INET6) || vflag&darwinInSockInfoIPv4 == 0 {
-			return darwinSocketNoMatch
-		}
-	} else {
-		if family != unix.AF_INET6 || vflag&darwinInSockInfoIPv6 == 0 {
-			return darwinSocketNoMatch
-		}
-	}
-
-	localPort := int32(darwinReadNativeUint32(info[darwinInSockInfoLPortOff : darwinInSockInfoLPortOff+4]))
-	if !darwinPortMatches(localPort, srcPort) {
-		return darwinSocketNoMatch
-	}
-	localAddrMatches := darwinAddrMatchesOrUnspecified(info[darwinInSockInfoLAddrOff:darwinInSockInfoLAddrOff+16], srcAddr)
-
-	foreignAddrRaw := info[darwinInSockInfoFAddrOff : darwinInSockInfoFAddrOff+16]
-	foreignPort := int32(darwinReadNativeUint32(info[darwinInSockInfoFPortOff : darwinInSockInfoFPortOff+4]))
-
-	if !hasDstAddr {
-		if localAddrMatches {
-			return darwinSocketExactMatch
-		}
-		return darwinSocketNoMatch
-	}
-
-	remoteMatches := darwinPortMatches(foreignPort, dstPort) && darwinAddrMatches(foreignAddrRaw, dstAddr)
-	if network == "udp" && darwinEndpointIsZero(foreignAddrRaw, foreignPort) && localAddrMatches {
-		return darwinSocketExactMatch
-	}
-	switch {
-	case localAddrMatches && remoteMatches:
-		return darwinSocketExactMatch
-	case localAddrMatches:
-		return darwinSocketLocalMatch
-	case remoteMatches:
-		return darwinSocketRemoteMatch
-	default:
-		return darwinSocketPortMatch
-	}
-}
-
-func darwinPortMatches(value int32, port uint16) bool {
-	raw := uint16(value)
-	return raw == port || darwinNtohs(raw) == port
-}
-
-func darwinNtohs(value uint16) uint16 {
-	return value<<8 | value>>8
-}
-
-func darwinAddrMatches(raw []byte, addr netip.Addr) bool {
-	if addr.Is4() {
-		ip := addr.As4()
-		return bytes.Equal(raw[12:16], ip[:])
-	}
-	ip := addr.As16()
-	return bytes.Equal(raw, ip[:])
-}
-
-func darwinAddrMatchesOrUnspecified(raw []byte, addr netip.Addr) bool {
-	if darwinAddrMatches(raw, addr) {
-		return true
-	}
-	if addr.Is4() {
-		return darwinBytesAreZero(raw[12:16])
-	}
-	return darwinBytesAreZero(raw)
-}
-
-func darwinEndpointIsZero(rawAddr []byte, port int32) bool {
-	return uint32(port) == 0 && darwinBytesAreZero(rawAddr)
-}
-
-func darwinBytesAreZero(raw []byte) bool {
-	for _, value := range raw {
-		if value != 0 {
-			return false
-		}
-	}
-	return true
-}
-
-func darwinReadNativeUint32(b []byte) uint32 {
-	return *(*uint32)(unsafe.Pointer(&b[0]))
-}
-
-func darwinProcessPath(pid int32) (string, error) {
-	buf := make([]byte, unix.PathMax)
-	n, err := darwinProcPIDPath(pid, buf)
-	if err != nil {
-		return "", err
-	}
-	if n <= 0 {
-		return "", errors.New("empty process path")
-	}
-	return strings.TrimRight(string(buf[:n]), "\x00"), nil
-}
-
-func darwinProcPIDInfo(pid int32, flavor int, arg uint64, buf []byte) (int, error) {
-	var ptr unsafe.Pointer
-	if len(buf) > 0 {
-		ptr = unsafe.Pointer(&buf[0])
-	}
-
-	r0, _, errno := syscall_syscall6(libc_proc_pidinfo_trampoline_addr, uintptr(pid), uintptr(flavor), uintptr(arg), uintptr(ptr), uintptr(len(buf)), 0)
-	if errno != 0 {
-		return 0, errno
-	}
-	return int(r0), nil
-}
-
-func darwinProcPIDFDInfo(pid int32, fd int32, flavor int, buf []byte) (int, error) {
-	var ptr unsafe.Pointer
-	if len(buf) > 0 {
-		ptr = unsafe.Pointer(&buf[0])
-	}
-
-	r0, _, errno := syscall_syscall6(libc_proc_pidfdinfo_trampoline_addr, uintptr(pid), uintptr(fd), uintptr(flavor), uintptr(ptr), uintptr(len(buf)), 0)
-	if errno != 0 {
-		return 0, errno
-	}
-	return int(r0), nil
-}
-
-func darwinProcPIDPath(pid int32, buf []byte) (int, error) {
-	r0, _, errno := syscall_syscall6(libc_proc_pidpath_trampoline_addr, uintptr(pid), uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0, 0, 0)
-	if errno != 0 {
-		return 0, errno
-	}
-	return int(r0), nil
-}
-
-var libc_proc_pidinfo_trampoline_addr uintptr
-
-//go:cgo_import_dynamic libc_proc_pidinfo proc_pidinfo "/usr/lib/libproc.dylib"
-
-var libc_proc_pidfdinfo_trampoline_addr uintptr
-
-//go:cgo_import_dynamic libc_proc_pidfdinfo proc_pidfdinfo "/usr/lib/libproc.dylib"
-
-var libc_proc_pidpath_trampoline_addr uintptr
-
-//go:cgo_import_dynamic libc_proc_pidpath proc_pidpath "/usr/lib/libproc.dylib"
-
-// Implemented in the runtime package (runtime/sys_darwin.go).
-func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
-
-//go:linkname syscall_syscall6 syscall.syscall6
@@ -1,18 +0,0 @@
-//go:build darwin && !ios
-
-#include "textflag.h"
-
-TEXT libc_proc_pidinfo_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_proc_pidinfo(SB)
-GLOBL	·libc_proc_pidinfo_trampoline_addr(SB), RODATA, $8
-DATA	·libc_proc_pidinfo_trampoline_addr(SB)/8, $libc_proc_pidinfo_trampoline<>(SB)
-
-TEXT libc_proc_pidfdinfo_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_proc_pidfdinfo(SB)
-GLOBL	·libc_proc_pidfdinfo_trampoline_addr(SB), RODATA, $8
-DATA	·libc_proc_pidfdinfo_trampoline_addr(SB)/8, $libc_proc_pidfdinfo_trampoline<>(SB)
-
-TEXT libc_proc_pidpath_trampoline<>(SB),NOSPLIT,$0-0
-	JMP	libc_proc_pidpath(SB)
-GLOBL	·libc_proc_pidpath_trampoline_addr(SB), RODATA, $8
-DATA	·libc_proc_pidpath_trampoline_addr(SB)/8, $libc_proc_pidpath_trampoline<>(SB)
@@ -1,356 +0,0 @@
-//go:build darwin && !ios
-
-package net
-
-import (
-	stdnet "net"
-	"net/netip"
-	"os"
-	"testing"
-	"time"
-	"unsafe"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestFindProcessDarwinTCP(t *testing.T) {
-	listener, err := stdnet.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	accepted := make(chan stdnet.Conn, 1)
-	go func() {
-		conn, err := listener.Accept()
-		if err == nil {
-			accepted <- conn
-			return
-		}
-		close(accepted)
-	}()
-
-	conn, err := stdnet.Dial("tcp", listener.Addr().String())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	serverConn := <-accepted
-	if serverConn == nil {
-		t.Fatal("server did not accept tcp connection")
-	}
-	defer serverConn.Close()
-
-	local := conn.LocalAddr().(*stdnet.TCPAddr)
-	remote := conn.RemoteAddr().(*stdnet.TCPAddr)
-
-	pid, name, path, err := FindProcess("tcp", local.IP.String(), uint16(local.Port), remote.IP.String(), uint16(remote.Port))
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertCurrentProcess(t, pid, name, path)
-}
-
-func TestFindProcessDarwinTCPIPv4Mapped(t *testing.T) {
-	listener, err := stdnet.Listen("tcp4", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	accepted := make(chan stdnet.Conn, 1)
-	go func() {
-		conn, err := listener.Accept()
-		if err == nil {
-			accepted <- conn
-			return
-		}
-		close(accepted)
-	}()
-
-	listenerAddr := listener.Addr().(*stdnet.TCPAddr)
-	fd, err := unix.Socket(unix.AF_INET6, unix.SOCK_STREAM, unix.IPPROTO_TCP)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer unix.Close(fd)
-
-	mappedAddr := [16]byte{10: 0xff, 11: 0xff, 12: 127, 15: 1}
-	if err := unix.Connect(fd, &unix.SockaddrInet6{
-		Port: listenerAddr.Port,
-		Addr: mappedAddr,
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	serverConn := <-accepted
-	if serverConn == nil {
-		t.Fatal("server did not accept tcp connection")
-	}
-	defer serverConn.Close()
-
-	local, err := unix.Getsockname(fd)
-	if err != nil {
-		t.Fatal(err)
-	}
-	localPort := local.(*unix.SockaddrInet6).Port
-
-	pid, name, path, err := FindProcess("tcp", "127.0.0.1", uint16(localPort), "127.0.0.1", uint16(listenerAddr.Port))
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertCurrentProcess(t, pid, name, path)
-}
-
-func TestFindProcessDarwinUDP(t *testing.T) {
-	conn, err := stdnet.ListenUDP("udp", &stdnet.UDPAddr{IP: stdnet.ParseIP("127.0.0.1")})
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	local := conn.LocalAddr().(*stdnet.UDPAddr)
-
-	pid, name, path, err := FindProcess("udp", local.IP.String(), uint16(local.Port), "", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertCurrentProcess(t, pid, name, path)
-}
-
-func TestFindProcessDarwinNonLocal(t *testing.T) {
-	_, _, _, err := FindProcess("tcp", "203.0.113.1", 80, "", 0)
-	if err != ErrNotLocal {
-		t.Fatalf("expected ErrNotLocal, got %v", err)
-	}
-}
-
-func TestFindProcessDarwinUnsupportedNetwork(t *testing.T) {
-	defer func() {
-		if recover() == nil {
-			t.Fatal("expected panic")
-		}
-	}()
-
-	_, _, _, _ = FindProcess("icmp", "127.0.0.1", 0, "", 0)
-}
-
-func assertCurrentProcess(t *testing.T, pid int, name string, path string) {
-	t.Helper()
-
-	if pid != os.Getpid() {
-		t.Fatalf("expected pid %d, got %d (%s, %s)", os.Getpid(), pid, name, path)
-	}
-
-	executable, err := os.Executable()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if path == "" || name == "" {
-		t.Fatalf("expected process path and name, got name=%q path=%q", name, path)
-	}
-	if sameFile(executable, path) {
-		return
-	}
-	t.Fatalf("expected executable %q, got %q", executable, path)
-}
-
-func sameFile(left string, right string) bool {
-	leftInfo, leftErr := os.Stat(left)
-	rightInfo, rightErr := os.Stat(right)
-	if leftErr != nil || rightErr != nil {
-		return false
-	}
-	return os.SameFile(leftInfo, rightInfo)
-}
-
-func TestFindProcessDarwinTCPWithoutDestination(t *testing.T) {
-	listener, err := stdnet.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	accepted := make(chan stdnet.Conn, 1)
-	go func() {
-		conn, err := listener.Accept()
-		if err == nil {
-			accepted <- conn
-			return
-		}
-		close(accepted)
-	}()
-
-	conn, err := stdnet.DialTimeout("tcp", listener.Addr().String(), time.Second)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	serverConn := <-accepted
-	if serverConn == nil {
-		t.Fatal("server did not accept tcp connection")
-	}
-	defer serverConn.Close()
-
-	local := conn.LocalAddr().(*stdnet.TCPAddr)
-	pid, name, path, err := FindProcess("tcp", local.IP.String(), uint16(local.Port), "", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertCurrentProcess(t, pid, name, path)
-}
-
-func TestFindProcessDarwinTCPWithDifferentDestination(t *testing.T) {
-	listener, err := stdnet.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	accepted := make(chan stdnet.Conn, 1)
-	go func() {
-		conn, err := listener.Accept()
-		if err == nil {
-			accepted <- conn
-			return
-		}
-		close(accepted)
-	}()
-
-	conn, err := stdnet.DialTimeout("tcp", listener.Addr().String(), time.Second)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	serverConn := <-accepted
-	if serverConn == nil {
-		t.Fatal("server did not accept tcp connection")
-	}
-	defer serverConn.Close()
-
-	local := conn.LocalAddr().(*stdnet.TCPAddr)
-	pid, name, path, err := FindProcess("tcp", local.IP.String(), uint16(local.Port), "203.0.113.10", 443)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertCurrentProcess(t, pid, name, path)
-}
-
-func TestDarwinSocketInfoMatchLevelFallbacks(t *testing.T) {
-	src := netip.MustParseAddr("198.18.0.2")
-	dst := netip.MustParseAddr("203.0.113.10")
-	otherLocal := netip.MustParseAddr("192.168.1.10")
-	otherRemote := netip.MustParseAddr("198.51.100.10")
-	unspecifiedLocal := netip.MustParseAddr("0.0.0.0")
-
-	tests := []struct {
-		name      string
-		local     netip.Addr
-		remote    netip.Addr
-		hasDst    bool
-		wantLevel darwinSocketMatchLevel
-	}{
-		{
-			name:      "exact",
-			local:     src,
-			remote:    dst,
-			hasDst:    true,
-			wantLevel: darwinSocketExactMatch,
-		},
-		{
-			name:      "unspecified local with matching remote",
-			local:     unspecifiedLocal,
-			remote:    dst,
-			hasDst:    true,
-			wantLevel: darwinSocketExactMatch,
-		},
-		{
-			name:      "unspecified local without destination",
-			local:     unspecifiedLocal,
-			remote:    otherRemote,
-			hasDst:    false,
-			wantLevel: darwinSocketExactMatch,
-		},
-		{
-			name:      "local match with different remote",
-			local:     src,
-			remote:    otherRemote,
-			hasDst:    true,
-			wantLevel: darwinSocketLocalMatch,
-		},
-		{
-			name:      "remote match with different local",
-			local:     otherLocal,
-			remote:    dst,
-			hasDst:    true,
-			wantLevel: darwinSocketRemoteMatch,
-		},
-		{
-			name:      "port only with destination",
-			local:     otherLocal,
-			remote:    otherRemote,
-			hasDst:    true,
-			wantLevel: darwinSocketPortMatch,
-		},
-		{
-			name:      "different local without destination",
-			local:     otherLocal,
-			remote:    otherRemote,
-			hasDst:    false,
-			wantLevel: darwinSocketNoMatch,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			info := newDarwinSocketInfo("tcp", test.local, 12345, test.remote, 443)
-			level := darwinSocketInfoMatchLevel(info, "tcp", src, 12345, dst, 443, test.hasDst)
-			if level != test.wantLevel {
-				t.Fatalf("unexpected match level: got %d, want %d", level, test.wantLevel)
-			}
-		})
-	}
-}
-
-func TestDarwinSocketInfoMatchLevelIPv4Mapped(t *testing.T) {
-	src := netip.MustParseAddr("127.0.0.1")
-	dst := netip.MustParseAddr("203.0.113.10")
-	info := newDarwinSocketInfo("tcp", src, 12345, dst, 443)
-	writeDarwinNativeUint32(info, darwinSocketInfoFamilyOff, uint32(unix.AF_INET6))
-
-	level := darwinSocketInfoMatchLevel(info, "tcp", src, 12345, dst, 443, true)
-	if level != darwinSocketExactMatch {
-		t.Fatalf("unexpected match level: got %d, want %d", level, darwinSocketExactMatch)
-	}
-}
-
-func newDarwinSocketInfo(network string, local netip.Addr, localPort uint16, remote netip.Addr, remotePort uint16) []byte {
-	info := make([]byte, darwinSocketFDInfoSize)
-	switch network {
-	case "tcp":
-		writeDarwinNativeUint32(info, darwinSocketInfoProtoOff, uint32(unix.IPPROTO_TCP))
-		writeDarwinNativeUint32(info, darwinSocketInfoKindOff, uint32(darwinSockInfoTCP))
-	case "udp":
-		writeDarwinNativeUint32(info, darwinSocketInfoProtoOff, uint32(unix.IPPROTO_UDP))
-		writeDarwinNativeUint32(info, darwinSocketInfoKindOff, uint32(darwinSockInfoIN))
-	}
-	writeDarwinNativeUint32(info, darwinSocketInfoFamilyOff, uint32(unix.AF_INET))
-	info[darwinInSockInfoVFlagOff] = darwinInSockInfoIPv4
-	writeDarwinNativeUint32(info, darwinInSockInfoLPortOff, uint32(localPort))
-	writeDarwinNativeUint32(info, darwinInSockInfoFPortOff, uint32(remotePort))
-	copyDarwinIPv4(info[darwinInSockInfoLAddrOff:darwinInSockInfoLAddrOff+16], local)
-	copyDarwinIPv4(info[darwinInSockInfoFAddrOff:darwinInSockInfoFAddrOff+16], remote)
-	return info
-}
-
-func writeDarwinNativeUint32(b []byte, offset int, value uint32) {
-	*(*uint32)(unsafe.Pointer(&b[offset])) = value
-}
-
-func copyDarwinIPv4(dst []byte, addr netip.Addr) {
-	ip := addr.As4()
-	copy(dst[12:16], ip[:])
-}
@@ -1,11 +0,0 @@
-//go:build ios
-
-package net
-
-import (
-	"github.com/xtls/xray-core/common/errors"
-)
-
-func FindProcess(network, srcIP string, srcPort uint16, destIP string, destPort uint16) (int, string, string, error) {
-	return 0, "", "", errors.New("process lookup is not supported on this platform")
-}
@@ -1,4 +1,4 @@
-//go:build !windows && !linux && !android && !darwin
+//go:build !windows && !linux && !android

 package net

@@ -1,40 +0,0 @@
-package platform
-
-import (
-	"errors"
-	"sync"
-)
-
-var envReloadRegistry = struct {
-	sync.RWMutex
-	handlers []func() error
-}{}
-
-// RegisterEnvReload registers an environment reload handler and runs it once
-// immediately so package defaults keep the same behavior as init-time reads.
-func RegisterEnvReload(handler func() error) {
-	if handler == nil {
-		return
-	}
-	envReloadRegistry.Lock()
-	envReloadRegistry.handlers = append(envReloadRegistry.handlers, handler)
-	envReloadRegistry.Unlock()
-	if err := handler(); err != nil {
-		panic(err)
-	}
-}
-
-// ReloadEnvSettings refreshes all registered environment-backed package state.
-func ReloadEnvSettings() error {
-	envReloadRegistry.RLock()
-	handlers := append([]func() error{}, envReloadRegistry.handlers...)
-	envReloadRegistry.RUnlock()
-
-	var errs []error
-	for _, handler := range handlers {
-		if err := handler(); err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return errors.Join(errs...)
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
copilot-swe-agent[bot]GitHub RPRX	e088cc4a25	Preserve startup error when browser dialer cleanup fails Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b8c640ab-f93c-4609-8e34-a8e14e2be9e7 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 13:38:42 +00:00
copilot-swe-agent[bot]GitHub RPRX	41bc47b1ec	Handle browser dialer cleanup errors on instance lifecycle Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b8c640ab-f93c-4609-8e34-a8e14e2be9e7 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 13:36:11 +00:00
copilot-swe-agent[bot]GitHub RPRX	8043924af5	Move browser dialer start stop to instance lifecycle Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b8c640ab-f93c-4609-8e34-a8e14e2be9e7 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 13:32:47 +00:00
copilot-swe-agent[bot]GitHub RPRX	3a826b7ece	docs: clarify idempotent browser dialer listener startup Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/bd037532-6fba-48d4-bf72-77fbb3bf8fc4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 11:55:25 +00:00
copilot-swe-agent[bot]GitHub RPRX	ccac265911	chore: make browser dialer listener startup idempotent Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/bd037532-6fba-48d4-bf72-77fbb3bf8fc4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 11:52:48 +00:00
copilot-swe-agent[bot]GitHub RPRX	c423317305	fix: split browser dialer configure and listener startup phases Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/bd037532-6fba-48d4-bf72-77fbb3bf8fc4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-27 11:50:15 +00:00
copilot-swe-agent[bot]GitHub RPRX	286a702bfa	refactor: split browser dialer manager logic to keep dialer.go minimal Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/2f611863-296d-48df-b3c4-e02384132848 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 21:28:35 +00:00
copilot-swe-agent[bot]GitHub RPRX	9d4dd2c32f	refactor: switch browser dialer scheme back to browser and trim wrappers Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/4df6450c-a247-4e14-951f-2859a7875fe3 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 21:18:00 +00:00
copilot-swe-agent[bot]GitHub RPRX	8939657016	refactor: drop socket proto browser_dialer and remove dialer init locks Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b6b773ed-3d59-4a25-b688-8032a496a8de Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 21:07:28 +00:00
copilot-swe-agent[bot]GitHub RPRX	f1f0d5970a	fix: require full valid browser dialer URL for http scheme Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/de6da8b1-0d9b-4d56-a5a2-d0b06edc2965 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:56:05 +00:00
copilot-swe-agent[bot]GitHub RPRX	3004e1e399	refactor: use http:// dialerProxy scheme for browser dialer Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/de6da8b1-0d9b-4d56-a5a2-d0b06edc2965 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:54:10 +00:00
copilot-swe-agent[bot]GitHub RPRX	2ecfbcf1b6	chore: align browser dialer collection error style Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/84d72770-6ad0-447a-8d86-94d692972a05 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:50:38 +00:00
copilot-swe-agent[bot]GitHub RPRX	9f8f5c2591	chore: polish browser dialer URL collection error message Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/84d72770-6ad0-447a-8d86-94d692972a05 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:49:28 +00:00
copilot-swe-agent[bot]GitHub RPRX	bb79f554dd	fix: tighten browser URL collection order and error handling Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/84d72770-6ad0-447a-8d86-94d692972a05 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:48:03 +00:00
copilot-swe-agent[bot]GitHub RPRX	be9a229d68	refactor: switch browser dialer to browser:// dialerProxy collection Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/84d72770-6ad0-447a-8d86-94d692972a05 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 20:46:22 +00:00
copilot-swe-agent[bot]GitHub RPRX	7416fd225e	refactor: simplify browser dialer parsed path normalization Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/56a85a3a-5e08-44ce-97d9-d441379c11cc Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 19:02:41 +00:00
copilot-swe-agent[bot]GitHub RPRX	e79f3a4361	fix: normalize parsed browser dialer path with explicit leading slash Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/56a85a3a-5e08-44ce-97d9-d441379c11cc Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 19:00:58 +00:00
copilot-swe-agent[bot]GitHub RPRX	9421ac0b13	refactor: further simplify browser dialer URL parsing path Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/56a85a3a-5e08-44ce-97d9-d441379c11cc Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 18:59:10 +00:00
copilot-swe-agent[bot]GitHub RPRX	7a9c592221	refactor: use browserDialers URL array and dialerProxy URL matching Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/6ed9ad08-e0b0-43d4-878b-7fe355be5325 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 18:49:21 +00:00
copilot-swe-agent[bot]GitHub RPRX	266ae17654	refactor: simplify browser dialer static state and remove sockopt browserDialer parsing Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/4875f50c-9a90-4d34-afbe-2e629296faa0 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 18:38:07 +00:00
copilot-swe-agent[bot]GitHub RPRX	1cc7349529	refactor: enforce browserDialers-only usage via dialerProxy tags Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/92209153-115a-4303-8c4e-5825c971881b Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 18:23:29 +00:00
copilot-swe-agent[bot]GitHub RPRX	61c39a2834	chore: align browserDialers runtime error wording Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/808be5b1-7ed2-4309-87f1-18a808d6aba4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:57:52 +00:00
copilot-swe-agent[bot]GitHub RPRX	1d13700481	chore: polish browserDialers xhttp runtime error client behavior Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/808be5b1-7ed2-4309-87f1-18a808d6aba4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:56:03 +00:00
copilot-swe-agent[bot]GitHub RPRX	ca3cd5fb88	feat: add root browserDialers tags for dialerProxy integration Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/808be5b1-7ed2-4309-87f1-18a808d6aba4 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:54:10 +00:00
copilot-swe-agent[bot]GitHub RPRX	97ad6cef43	chore: polish xhttp browser dialer mode validation messages Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/071df77b-69fb-4b1f-a14d-9dab447e1efa Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:20:23 +00:00
copilot-swe-agent[bot]GitHub RPRX	181193581b	chore: improve xhttp browser dialer validation errors Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/071df77b-69fb-4b1f-a14d-9dab447e1efa Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:18:37 +00:00
copilot-swe-agent[bot]GitHub RPRX	5906445c68	fix: restrict xhttp browser dialer mode and remove added tests Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/071df77b-69fb-4b1f-a14d-9dab447e1efa Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 17:16:42 +00:00
copilot-swe-agent[bot]GitHub RPRX	a54c54a559	fix: enforce same-port different-address browser dialer rejection Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b21c3fc4-8476-4107-975a-9d921d55ffea Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:42:56 +00:00
copilot-swe-agent[bot]GitHub RPRX	64f783f2b0	fix: allow same-address browser dialer port reuse across outbounds Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b21c3fc4-8476-4107-975a-9d921d55ffea Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:39:27 +00:00
copilot-swe-agent[bot]GitHub RPRX	12ecf47fcc	fix: clean browser dialer path parsing guard Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/3aee4c73-7847-433c-905a-2eafe5b1bfe8 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:27:13 +00:00
copilot-swe-agent[bot]GitHub RPRX	4636ca2675	fix: clean up dialer refactor review issues Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/3aee4c73-7847-433c-905a-2eafe5b1bfe8 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:25:25 +00:00
copilot-swe-agent[bot]GitHub RPRX	5afd664c8b	refactor: simplify browser dialer and remove added conf tests Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/3aee4c73-7847-433c-905a-2eafe5b1bfe8 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:23:37 +00:00
copilot-swe-agent[bot]GitHub RPRX	1d4250e6f0	fix: normalize browser dialer UUID before parsing Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/d0035ff5-3633-402f-890e-e68c267a65c1 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:07:23 +00:00
copilot-swe-agent[bot]GitHub RPRX	e06c536ce6	refactor: tighten browser dialer UUID and config error handling Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/d0035ff5-3633-402f-890e-e68c267a65c1 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:05:57 +00:00
copilot-swe-agent[bot]GitHub RPRX	aeb689284c	feat: validate and initialize browser dialer at config build Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/d0035ff5-3633-402f-890e-e68c267a65c1 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 16:03:45 +00:00
copilot-swe-agent[bot]GitHub RPRX	9ad099774a	refactor: simplify browser dialer UUID path validation Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/9288cc3c-d788-49d9-8bdc-f03281c238bf Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 15:54:00 +00:00
copilot-swe-agent[bot]GitHub RPRX	8fca7745fb	feat: require UUID path for sockopt browser dialer Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/f1db6008-e292-4b43-a2e0-0bc80567ebba Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 15:49:47 +00:00
copilot-swe-agent[bot]GitHub RPRX	57253b736d	refactor: use path plus header for browser dialer upgrade Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/33541da0-fdc4-4415-b7c4-7183f01b762e Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 15:43:35 +00:00
copilot-swe-agent[bot]GitHub RPRX	c48c475256	feat: require browserDialer path and multiplex by path Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/d3d25e7b-e62f-49e0-90be-0ca7f974e115 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 15:20:37 +00:00
copilot-swe-agent[bot]GitHub RPRX	2691a1aa0e	feat: use path-based browser dialer csrf endpoint Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/b6b47cc0-5a64-49d5-9447-22c9c202c95d Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 15:01:48 +00:00
copilot-swe-agent[bot]GitHub RPRX	84d04d0eab	chore: warn legacy browser dialer env has been removed Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/d30a26b2-60aa-4f86-b2ed-3c6997652bfb Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 07:55:48 +00:00
copilot-swe-agent[bot]GitHub RPRX	27b8b29ef8	refactor: remove browser dialer env reload path and refresh proto metadata Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/e3502f01-e171-4e6f-9ae7-dc29b6682951 Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 07:44:58 +00:00
copilot-swe-agent[bot]GitHub RPRX	2fdfa727b4	refactor: improve browser dialer instance handling and diagnostics Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/56665ec5-84ea-4bc3-a812-2e699e0e880d Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 07:26:34 +00:00
copilot-swe-agent[bot]GitHub RPRX	c2116bb869	feat: add browserDialer under sockopt and wire transports Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/56665ec5-84ea-4bc3-a812-2e699e0e880d Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>	2026-04-26 07:22:38 +00:00
				`@@ -1 +0,0 @@`
				`powershell.exe -ExecutionPolicy Bypass -File ".\xray_no_window.ps1"`
				`@@ -1 +0,0 @@`
				`Start-Process -FilePath ".\xray.exe" -ArgumentList "-config .\config.json" -WindowStyle Hidden`
				`@@ -1 +0,0 @@`
				`CreateObject("Wscript.Shell").Run "xray.exe -config config.json",0`