fix(node): ASN WHOIS 支持多 RIR 解析，补 ASN 库兜底与缓存键归一化

现象：/v1/asn/:ip 与 ws 的 asn 路径，除 1.1.1.1（AS13335，ARIN 注册）外全部拿不到 whois 信息。解析侧 src/webtest/whois.go - 根因：parseASNWhoisRaw 只认 ARIN 字段名（ASNumber/ASName/OrgName/OrgAbuse*），而 QueryASNWhois 走 IANA → 归属 RIR 链路，非 ARIN 的 ASN 回的是 aut-num/ as-name/descr/country/last-modified 格式，于是字段解析全空 - 另一坑：ARIN 对非 ARIN 资源只回转介桩（ASName: APNIC-4134 + ReferralServer），同一条 raw 里存在两段内容，桩的字段是误导信息 - 改为按空行分块解析：存在原生 aut-num 块时以它为准、整体忽略 ARIN 段；字段按 RIR 分级取值（RIPE 的组织名与国别按 aut-num 的 org: 句柄定位 organisation 对象） - abuse 优先取 % Abuse contact 注释行，其次含 abuse-mailbox 的对象 - 实网验证 22/22 全解析（电信/联通/移动/阿里/腾讯/百度/华为 + CF/Google/Amazon/ Hetzner/Linode 等），覆盖 ARIN+APNIC+RIPE 三类 RIR 消费侧 src/main.go src/ws.go - 新增 resolveASN()：ASN 来源按 maxmind → dbip → ip2location 逐级兜底。此前只认 maxmind_asn，某 IP 未命中该库时整段 whois 直接消失，哪怕另两个库有数据 - 新增 normalizeASN()：MMDBASNResult.ASN 自带 "AS" 前缀，ip2location 的 asn 是裸数字，缓存键与查询入参统一归一化（此前 "AS"+ASN 实际拼成 ASAS13335） - 新增 lookupASNWhois()：handler 与 ws 共用同一套缓存 —— ws 路径此前完全没有缓存，每个请求都真查一次 WHOIS - 新增 asnWhoisFailed()：likexian/whois 出错时返回 (result, nil)，错误塞在 result.Error 里；老代码只判 err != nil（恒为假）⇒ 失败结果被当成功缓存 5min，现按失败走 30s TTL
fix(frontend-ssr): 手机端两 IP 块间大空隙——min-height 只留给 IPv6 行，IP 行 margin 归零
2026-10-05 20:51:01 +08:00 · 2026-10-05 09:58:18 +08:00 · 2026-10-05 01:56:25 +08:00 · 2026-10-05 01:56:24 +08:00 · 2026-10-05 01:55:57 +08:00 · 2026-10-04 15:49:16 +08:00
49 changed files with 2961 additions and 966 deletions
@@ -1,6 +1,11 @@
 name: Build and Release

-
+# 并行构建：原来 8 个 Build step 串行跑在一个 job 里，现在拆成 8 个矩阵任务同时跑
+#   （2 个程序 × 4 个目标系统），构建完各自上传 artifact，最后统一发 Release。
+#
+# 元数据（VERSION / COMMIT / BUILD_TIME）由 meta job 算一次分发下去：
+# 若放到每个矩阵任务里各算一遍，BUILD_TIME 会互不相同，同一个 Release 里的
+# 二进制时间戳就对不上了。
 on:
  push:
    tags:
@@ -8,95 +13,131 @@ on:
  workflow_dispatch:

 jobs:
-    build-and-release:
+    # 只负责算版本元数据，秒级完成，不产出 artifact
+    meta:
        runs-on: ubuntu-latest
+        outputs:
+            ldflags: ${{ steps.meta.outputs.ldflags }}
+        steps:
+            - name: Compute version metadata
+              id: meta
+              run: |
+                echo "ldflags=-X main.VERSION=${GITHUB_REF_NAME} -X main.COMMIT=${GITHUB_SHA} -X main.BUILD_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$GITHUB_OUTPUT"
+
+    build:
+        needs: meta
+        runs-on: ubuntu-latest
+        strategy:
+            # 一个目标挂了不影响其余目标，全部跑完再统一看结果
+            fail-fast: false
+            # 纯 include 模式：每条自带全部字段、各自独立成一个任务。
+            # 不要把 app 写成顶层数组再和 os 组合——GitHub 会把能匹配现有组合的
+            # include 条目合并进组合本身，任务数被折叠（docker.yml 里踩过，见 v3.3.0 事故）
+            matrix:
+                include:
+                    - app: lemonipw
+                      dir: src
+                      os: linux
+                    - app: lemonipw
+                      dir: src
+                      os: windows
+                    - app: lemonipw
+                      dir: src
+                      os: darwin
+                    - app: lemonipw
+                      dir: src
+                      os: freebsd
+                    - app: middleware-go
+                      dir: middleware-go
+                      os: linux
+                    - app: middleware-go
+                      dir: middleware-go
+                      os: windows
+                    - app: middleware-go
+                      dir: middleware-go
+                      os: darwin
+                    - app: middleware-go
+                      dir: middleware-go
+                      os: freebsd
        steps:
            - name: Checkout repository
              uses: actions/checkout@v4

            - name: Setup Go
-              uses: actions/setup-go@v4
+              # v4 基于 Node 16，GitHub 已不再支持该运行时（actionlint 会报 runner too old）
+              uses: actions/setup-go@v5
              with:
                go-version: '1.26.6' # 与 src/go.mod 声明保持一致，避免依赖 GOTOOLCHAIN 隐式下载
-            - name: Set version metadata
-              run: |
-                echo "VERSION=${GITHUB_REF_NAME}" >> $GITHUB_ENV  
-                echo "COMMIT=${GITHUB_SHA}" >> $GITHUB_ENV
-                echo "BUILD_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)" >> $GITHUB_ENV

-            - name: Build for Linux
-              working-directory: src
+            # 产物统一写到仓库根目录（working-directory 的上一级），命名规则与原串行版完全一致
+            - name: Build ${{ matrix.app }} for ${{ matrix.os }}
+              working-directory: ${{ matrix.dir }}
+              env:
+                APP: ${{ matrix.app }}
+                LDFLAGS: ${{ needs.meta.outputs.ldflags }}
              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-386
-                CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-amd64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-arm64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-armv7
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-armv6
-                CGO_ENABLED=0 GOOS=linux GOARCH=loong64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-loong64
-            - name: Build for Windows
-              working-directory: src
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=windows GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-386.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-amd64.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-arm64.exe
-            - name: Build for macOS
-              working-directory: src
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-darwin-amd64
-                CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-darwin-arm64
-            - name: Build for FreeBSD
-              working-directory: src
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-386
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-amd64
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-arm64
-            - name: Build middleware-go for Linux
-              working-directory: middleware-go
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-386
-                CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-amd64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-arm64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-armv7
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-armv6
-                CGO_ENABLED=0 GOOS=linux GOARCH=loong64 go build -ldflags "$LDFLAGS" -o ../middleware-go-linux-loong64
-            - name: Build middleware-go for Windows
-              working-directory: middleware-go
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=windows GOARCH=386 go build -ldflags "$LDFLAGS" -o ../middleware-go-windows-386.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../middleware-go-windows-amd64.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../middleware-go-windows-arm64.exe
-            - name: Build middleware-go for macOS
-              working-directory: middleware-go
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../middleware-go-darwin-amd64
-                CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../middleware-go-darwin-arm64
-            - name: Build middleware-go for FreeBSD
-              working-directory: middleware-go
-              run: |
-                LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags "$LDFLAGS" -o ../middleware-go-freebsd-386
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../middleware-go-freebsd-amd64
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../middleware-go-freebsd-arm64
+                set -euo pipefail
+                case "${{ matrix.os }}" in
+                  linux)
+                    CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-386"
+                    CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-amd64"
+                    CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-arm64"
+                    CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-armv7"
+                    CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-armv6"
+                    CGO_ENABLED=0 GOOS=linux GOARCH=loong64 go build -ldflags "$LDFLAGS" -o "../${APP}-linux-loong64"
+                    ;;
+                  windows)
+                    CGO_ENABLED=0 GOOS=windows GOARCH=386 go build -ldflags "$LDFLAGS" -o "../${APP}-windows-386.exe"
+                    CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$LDFLAGS" -o "../${APP}-windows-amd64.exe"
+                    CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build -ldflags "$LDFLAGS" -o "../${APP}-windows-arm64.exe"
+                    ;;
+                  darwin)
+                    CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$LDFLAGS" -o "../${APP}-darwin-amd64"
+                    CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$LDFLAGS" -o "../${APP}-darwin-arm64"
+                    ;;
+                  freebsd)
+                    CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags "$LDFLAGS" -o "../${APP}-freebsd-386"
+                    CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$LDFLAGS" -o "../${APP}-freebsd-amd64"
+                    CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o "../${APP}-freebsd-arm64"
+                    ;;
+                esac
+
+            - name: Upload ${{ matrix.app }}-${{ matrix.os }}
+              uses: actions/upload-artifact@v4
+              with:
+                name: ${{ matrix.app }}-${{ matrix.os }}
+                # 只捞本任务自己产出的二进制；middleware-go/ 目录名不带连字符，不会误匹配
+                path: ${{ matrix.app }}-*
+                if-no-files-found: error
+
+    # 只在打 tag 时发 Release；workflow_dispatch 手动跑则只构建、可从 run 页面下载 artifact
+    release:
+        needs: build
+        if: github.ref_type == 'tag'
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Download all build artifacts
+              uses: actions/download-artifact@v4
+              with:
+                path: dist
+                merge-multiple: true
+
            - name: Prepare config files for release
              run: |
                # 后端：发布 src/ 下的 setting.json.example；中间件：只发布 setting.json.example
-                cp src/setting.json.example setting.json.example
-                cp middleware-go/setting.json.example middleware.setting.json.example
+                cp src/setting.json.example dist/setting.json.example
+                cp middleware-go/setting.json.example dist/middleware.setting.json.example
+
            - name: Release
              uses: softprops/action-gh-release@v3
-              if: github.ref_type == 'tag'
              with:
                name: Release ${{ github.ref_name }}
                tag_name: ${{ github.ref_name }}
                token: ${{ secrets.MINT_TOKEN }}
-                
+
                generate_release_notes: true
                body: |
                  ## 配置文件说明
@@ -116,34 +157,4 @@ jobs:
                  cp middleware.setting.json.example middleware-go/setting.json
                  ```

-                files: |
-                  lemonipw-linux-386
-                  lemonipw-linux-amd64
-                  lemonipw-linux-arm64
-                  lemonipw-linux-armv7
-                  lemonipw-linux-armv6
-                  lemonipw-linux-loong64
-                  lemonipw-windows-386.exe
-                  lemonipw-windows-amd64.exe
-                  lemonipw-windows-arm64.exe
-                  lemonipw-darwin-amd64
-                  lemonipw-darwin-arm64
-                  lemonipw-freebsd-386
-                  lemonipw-freebsd-amd64
-                  lemonipw-freebsd-arm64
-                  middleware-go-linux-386
-                  middleware-go-linux-amd64
-                  middleware-go-linux-arm64
-                  middleware-go-linux-armv7
-                  middleware-go-linux-armv6
-                  middleware-go-linux-loong64
-                  middleware-go-windows-386.exe
-                  middleware-go-windows-amd64.exe
-                  middleware-go-windows-arm64.exe
-                  middleware-go-darwin-amd64
-                  middleware-go-darwin-arm64
-                  middleware-go-freebsd-386
-                  middleware-go-freebsd-amd64
-                  middleware-go-freebsd-arm64
-                  setting.json.example
-                  middleware.setting.json.example
+                files: dist/*
@@ -1,11 +1,15 @@
-name: Build and Deploy to Cloudflare Workers
+name: (已停用自动部署) frontend-ssr → Cloudflare Workers

+# 前端已迁移到 frontend-svelte（SvelteKit + shadcn-svelte，包管理器 bun），
+# 自动部署改由 .github/workflows/frontend-svelte.yml 负责。
+#
+# 这里**刻意去掉 push 触发**：两个 workflow 都部署同名 Worker（wrangler.jsonc 里的 "ipw-cn"），
+# 若继续按 push 触发，改 frontend-ssr 会把新前端的线上版本覆盖掉。
+# 保留 workflow_dispatch 只是为了万一还需要临时用旧站顶一下（手动触发）。
+# 新前端确认稳定后，这个文件可以直接删除。
 on:
-  push:
-    branches: ['main']
-    paths:
-      - 'frontend-ssr/**'
  workflow_dispatch:
+
 jobs:
  deploy:
    runs-on: ubuntu-latest
@@ -0,0 +1,33 @@
+name: Build and Deploy frontend-svelte to Cloudflare Workers
+
+on:
+  push:
+    branches: ['main']
+    paths:
+      - 'frontend-svelte/**'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # 包管理器是 bun（见 frontend-svelte/bun.lock），不再用 pnpm/npm
+      - name: Setup bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      # 部署到 Cloudflare Workers
+      # --keep-vars：保留 Worker 上已配置的环境变量（如 API_KEYS），别被本次部署清掉
+      - name: Deploy to Cloudflare Workers
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+        run: |
+          cd frontend-svelte
+          bun install --frozen-lockfile
+          bun run build
+          bunx wrangler deploy --keep-vars
@@ -21,6 +21,39 @@ curl -fsSL https://raw.githubusercontent.com/nomdn/ipw-cn/main/install.sh -o ins
 - [节点 API 与协议](docs/guide/node-api.md)（业务接口、管理接口、WS 协议、上报协议）
 - [公开 API（/api/v1）](docs/guide/public-api.md)（收集中心程序化接口：鉴权、端点与响应示例、公开状态接口）

+## 贡献节点
+
+把一台闲置的 Linux 机器（VPS、软路由、小主机）贡献为公共拨测节点：
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/nomdn/ipw-cn/main/contribute.sh -o contribute.sh && sudo bash contribute.sh
+```
+
+脚本静默完成全部步骤，中途无需任何交互：
+
+- 自动挑选一个空闲高位端口（20000-65000），节点标识（节点 id / 注册 key / access-token）随机生成
+- 默认以 WS 方式**同时接入官方两个中间件**（多活，节点主动出站连接，无需公网放行端口）
+- 安装到 `/opt/lemon-ipw`，注册为 systemd 服务 `lemon-ipw` 并设置开机自启
+- 结束时打印节点信息（同时备份在 `/opt/lemon-ipw/node-info.txt`）
+
+把打印出来的信息发给管理员登记，节点即可上线（联系方式见文末）。
+
+| 选项 | 说明 |
+| --- | --- |
+| `--ipdb` | 启用 IP 数据库（首次启动后台下载约 450MB，默认关闭） |
+| `--port <n>` | 指定监听端口（默认随机空闲端口） |
+| `--ws-url <url>` | 改为接入自建中间件，逗号分隔可填多个（默认官方两个） |
+| `--version <tag>` | 指定版本（默认取 GitHub 最新 release） |
+| `--gh-proxy <p>` | GitHub 下载加速前缀，如 `https://ghfast.top/` |
+| `--dry-run` | 只检查环境并打印信息，不下载、不写 systemd |
+
+日常运维：
+
+```bash
+systemctl status lemon-ipw     # 查看状态
+journalctl -u lemon-ipw -f     # 跟踪日志
+```
+
 ## 项目结构

 ```
@@ -30,7 +63,8 @@ ipw-cn/
 ├── serverless/        # 独立组件 边缘/Serverless（edgeone、edgeone-getip、lemon-getip）
 ├── frontend-ssr/      # Nuxt 4 SSR 前端
 ├── docs/              # 文档站
-└── install.sh         # 一键安装脚本
+├── install.sh         # 一键安装脚本（自建完整部署）
+└── contribute.sh      # 贡献节点脚本（一台闲置机器接为公共节点）
 ```
 ## 友情链接
 ### 来自社区的IPW版本
@@ -49,6 +83,12 @@ ipw-cn/
 | DNS 查询 | miekg/dns（DoH / UDP 双通道 + 主从 failover） |
 | 部署 | Docker、Cloudflare Workers、EdgeOne Pages、systemd |

+## 联系方式
+
+- 邮箱：[iduhih777@outlook.com](mailto:iduhih777@outlook.com)
+- GitHub：[@nomdn](https://github.com/nomdn)
+- 站点：[nipw.cn](https://nipw.cn) ｜ 拨测控制台：[boce.wsmdn.top](https://boce.wsmdn.top)
+
 ## 许可证

 [GPL-3.0](LICENSE)
@@ -0,0 +1,541 @@
+#!/usr/bin/bash
+# ============================================================
+# 节点贡献脚本（静默安装）
+#
+# 用途：把一台闲置 Linux 机器贡献为拨测节点。
+#   - 全程无交互：端口自动挑一个空闲高位端口，节点标识随机生成
+#   - 命名与官方 install.sh 保持一致：二进制 lemonipw / 目录 /opt/lemon-ipw / 服务 lemon-ipw
+#   - 默认同时接入柠檬的两个中间件 WS 通道（多活，节点主动出站，无需公网放行端口）
+#   - 安装完成后打印节点信息，提交给管理员登记即可上线
+#
+# 用法：
+#   sudo bash contribute.sh                  # 全默认：系统级安装 + 自动端口 + 接 WS
+#   sudo bash contribute.sh --ipdb           # 启用 IP 数据库（首启后台下载 ~450MB）
+#   sudo bash contribute.sh --port 34567     # 指定端口
+#   bash contribute.sh                       # 非 root：自动装成 systemd --user 用户级服务（不询问）
+#   bash contribute.sh --user                # 显式指定用户级（与上面的自动降级等价）
+#   sudo bash contribute.sh --dry-run        # 只生成并打印信息，不下载、不落盘
+# ============================================================
+
+set -e
+
+# 默认同时接入的两个中间件（逗号分隔 = 节点侧同时连接全部、多活；
+# 任一断开只重连自己，不影响另一条连接）。顺序无关，收集中心放前面便于阅读。
+WS_URL_DEFAULT="wss://boce-api.api-ipw.wsmdn.top/ws,wss://middleware-1.api-ipw.wsmdn.top/ws"
+CONTACT_EMAIL="iduhih777@outlook.com"
+PORT_MIN=20000
+PORT_MAX=65000
+
+OPT_PORT=""
+OPT_WS_URL=""
+OPT_VERSION=""
+OPT_GH_PROXY=""
+OPT_IPDB="false"
+OPT_SCOPE=""
+DRY_RUN="false"
+
+usage() {
+    cat <<'EOF'
+用法: sudo bash contribute.sh [选项]
+
+  --port <n>        监听端口（默认：20000-65000 中的随机空闲端口）
+  --ws-url <url>    中间件 WS 地址，逗号分隔可多个（默认：柠檬两个中间件，同时连接）
+  --version <tag>   指定版本（默认：取 GitHub 最新 release）
+  --gh-proxy <p>    GitHub 下载加速前缀，如 https://ghfast.top/
+  --ipdb            启用 IP 数据库（首次启动后台下载，约 450MB；默认关闭）
+  --user            用户级安装（systemd --user，unit 写 ~/.config/systemd/user，无需 root）
+  --system          系统级安装（unit 写 /etc/systemd/system，需 root；非 root 下指定会直接报错）
+  --dry-run         只做检查与信息生成，不下载、不写 systemd
+  -h, --help        显示本帮助
+EOF
+}
+
+# ---------- 参数解析 ----------
+
+while [ $# -gt 0 ]; do
+    key="$1"
+    case "$key" in
+        --ipdb)     OPT_IPDB="true";  shift; continue ;;
+        --user)     OPT_SCOPE="user";   shift; continue ;;
+        --system)   OPT_SCOPE="system"; shift; continue ;;
+        --dry-run)  DRY_RUN="true";  shift; continue ;;
+        -h|--help)  usage; exit 0 ;;
+        --port|--ws-url|--version|--gh-proxy) ;;
+        *) echo "错误：未知参数 $key（用 --help 查看用法）" >&2; exit 1 ;;
+    esac
+    if [ $# -lt 2 ]; then
+        echo "错误：$key 缺少参数值（用 --help 查看用法）" >&2
+        exit 1
+    fi
+    case "$key" in
+        --port)     OPT_PORT="$2" ;;
+        --ws-url)   OPT_WS_URL="$2" ;;
+        --version)  OPT_VERSION="$2" ;;
+        --gh-proxy) OPT_GH_PROXY="$2" ;;
+    esac
+    shift 2
+done
+
+# ---------- 随机值生成 ----------
+
+# 生成 UUID（优先 /proc，其次 uuidgen，最后 /dev/urandom）
+gen_uuid() {
+    if [ -r /proc/sys/kernel/random/uuid ]; then
+        cat /proc/sys/kernel/random/uuid
+    elif command -v uuidgen >/dev/null 2>&1; then
+        uuidgen | tr 'A-Z' 'a-z'
+    else
+        od -An -N16 -tx1 /dev/urandom | tr -d ' \n' \
+            | sed 's/\(........\)\(....\)\(....\)\(....\)\(............\)/\1-\2-\3-\4-\5/'
+    fi
+}
+
+# 32 位十六进制令牌（去横线的 UUID）
+gen_token() { gen_uuid | tr -d '-'; }
+
+# ---------- 端口 ----------
+
+# 列出本机监听端口（ss 优先，netstat 次之）
+listening_ports() {
+    if command -v ss >/dev/null 2>&1; then
+        ss -ltn 2>/dev/null | awk 'NR>1 {print $4}'
+    elif command -v netstat >/dev/null 2>&1; then
+        netstat -ltn 2>/dev/null | awk 'NR>2 {print $4}'
+    else
+        return 1
+    fi
+}
+
+# 0 = 端口已被占用，1 = 空闲
+port_in_use() {
+    local p="$1" ports
+    ports=$(listening_ports || true)
+    if [ -n "$ports" ]; then
+        if printf '%s\n' "$ports" | sed 's/.*[.:]//' | grep -qx "$p"; then
+            return 0
+        fi
+        return 1
+    fi
+    # 兜底：连得上即视为被占用（无 ss / netstat 的极简系统）
+    if (exec 3<>"/dev/tcp/127.0.0.1/$p") 2>/dev/null; then
+        exec 3>&-
+        return 0
+    fi
+    return 1
+}
+
+# 随机高位端口（20000-65000），连续试探直到落到空闲端口
+pick_port() {
+    local i p
+    for i in $(seq 1 50); do
+        p=$(( (RANDOM * 32768 + RANDOM) % (PORT_MAX - PORT_MIN + 1) + PORT_MIN ))
+        if ! port_in_use "$p"; then
+            printf '%s' "$p"
+            return 0
+        fi
+    done
+    echo "错误：连续 50 次未找到空闲的高位端口，请用 --port 指定" >&2
+    exit 1
+}
+
+# ---------- 权限与 systemd 作用域 ----------
+
+# system = 系统级：写 /etc/systemd/system，开机自启走 multi-user.target（需 root）
+# user   = 用户级：写 ~/.config/systemd/user，开机自启走 default.target（systemd --user）
+if [ "$(id -u)" -ne 0 ]; then
+    case "$OPT_SCOPE" in
+        system)
+            # dry-run 只在本地打印信息，不落盘，不必真有 root
+            if [ "$DRY_RUN" != "true" ]; then
+                echo "错误：--system 需要 root 权限（写 /etc/systemd/system），请用 sudo 运行或改用 --user" >&2
+                exit 1
+            fi
+            SYSTEMD_MODE="system"
+            ;;
+        user)
+            SYSTEMD_MODE="user"
+            ;;
+        *)
+            # 非 root 且未指定作用域：本脚本定位是"静默安装"，直接降为用户级，不打断询问
+            SYSTEMD_MODE="user"
+            echo "提示：当前不是 root 环境，自动改用 systemd --user（用户级服务，仅对当前用户生效）。" >&2
+            echo "      如需系统级安装，请用 sudo 重新运行。" >&2
+            ;;
+    esac
+else
+    SYSTEMD_MODE="system"
+    if [ "$OPT_SCOPE" = "user" ]; then
+        SYSTEMD_MODE="user"
+        echo "提示：以 root 身份使用 --user，unit 会写到 root 的用户级目录（~/.config/systemd/user）" >&2
+    fi
+fi
+
+# ---------- 环境检查 ----------
+
+if [ "$DRY_RUN" != "true" ]; then
+    if ! command -v systemctl >/dev/null 2>&1; then
+        echo "错误：未检测到 systemd（systemctl 不存在），无法创建守护进程" >&2
+        exit 1
+    fi
+    # 用户级实例依赖登录会话与 DBus，容器 / cron 等环境常常拿不到，提前拦掉
+    if [ "$SYSTEMD_MODE" = "user" ] && ! systemctl --user list-units >/dev/null 2>&1; then
+        echo "错误：当前环境无法使用 systemd --user（无用户级 systemd 实例或缺少 DBus 会话）" >&2
+        echo "      可改用 sudo bash contribute.sh 做系统级安装" >&2
+        exit 1
+    fi
+    if ! command -v wget >/dev/null 2>&1 && ! command -v curl >/dev/null 2>&1; then
+        echo "错误：未找到 wget 或 curl，无法下载" >&2
+        exit 1
+    fi
+fi
+
+# 运维命令按作用域切换（用户级必须带 --user，否则查的是系统级命名空间）
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    CTL_CMD="systemctl --user"
+    JRN_CMD="journalctl --user -u"
+    SCOPE_LABEL="用户级 systemd --user"
+else
+    CTL_CMD="systemctl"
+    JRN_CMD="journalctl -u"
+    SCOPE_LABEL="系统级 systemd"
+fi
+sc() { if [ "$SYSTEMD_MODE" = "user" ]; then systemctl --user "$@"; else systemctl "$@"; fi; }
+jc() { if [ "$SYSTEMD_MODE" = "user" ]; then journalctl --user "$@"; else journalctl "$@"; fi; }
+
+# ---------- 架构检测 ----------
+case "$(uname -m)" in
+    x86_64)              ARCH_TAG="amd64" ;;
+    i386|i486|i586|i686) ARCH_TAG="386" ;;
+    aarch64|arm64)       ARCH_TAG="arm64" ;;
+    armv7l|armv7hl)      ARCH_TAG="armv7" ;;
+    armv6l)              ARCH_TAG="armv6" ;;
+    loongarch64)         ARCH_TAG="loong64" ;;
+    *)
+        echo "错误：不支持的架构 '$(uname -m)'" >&2
+        exit 1
+        ;;
+esac
+RELEASE_ASSET="lemonipw-linux-${ARCH_TAG}"
+
+# ---------- 命名（与 install.sh 保持一致） ----------
+
+# 二进制 / 安装目录 / 服务名统一固定为 lemon 系列，便于运维识别与排查；
+# 一台机器只跑一份，重跑本脚本 = 覆盖同名服务与目录。
+BIN_BASE="lemonipw"
+SERVICE_NAME="lemon-ipw"
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    INSTALL_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/lemon-ipw"
+    SERVICE_FILE="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user/${SERVICE_NAME}.service"
+    UNIT_USER_LINE=""
+    UNIT_NETWORK_LINES=""
+    UNIT_WANTED_BY="default.target"
+else
+    INSTALL_DIR="/opt/lemon-ipw"
+    SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
+    # 系统级 unit 的 User= 行与 network-online 依赖；用户级没有这两个概念
+    UNIT_USER_LINE="User=root
+"
+    UNIT_NETWORK_LINES="After=network-online.target
+Wants=network-online.target
+"
+    UNIT_WANTED_BY="multi-user.target"
+fi
+
+# 同名服务已存在（例如这台机器已经跑着一个节点）：再跑一次会用新生成的
+# 节点标识覆盖旧配置，旧节点在收集中心的记录就失效了，先提醒一句。
+if [ "$DRY_RUN" != "true" ] && [ -f "$SERVICE_FILE" ]; then
+    echo "提示：已存在服务 ${SERVICE_NAME}，本次会覆盖其配置并生成新的节点标识（旧标识在收集中心将失效）" >&2
+fi
+
+PORTS="${OPT_PORT:-$(pick_port)}"
+case "$PORTS" in
+    ""|*[!0-9]*)
+        echo "错误：端口必须是数字（当前值：$PORTS）" >&2
+        exit 1
+        ;;
+esac
+# 10# 前缀强制十进制：避免 "0800" 这类带前导 0 的值被当成八进制解析
+PORTS=$((10#$PORTS))
+if [ "$PORTS" -lt 1 ] || [ "$PORTS" -gt 65535 ]; then
+    echo "错误：端口超出范围 1-65535（当前值：$PORTS）" >&2
+    exit 1
+fi
+if [ -n "$OPT_PORT" ] && port_in_use "$PORTS"; then
+    echo "警告：端口 $PORTS 当前已被占用，节点可能启动失败" >&2
+fi
+
+WS_URL="${OPT_WS_URL:-$WS_URL_DEFAULT}"
+# 逐段校验（逗号分隔可多个），并去掉段内空格：节点侧虽会 trim，
+# 但空格会原样进 systemd 的 Environment 值，还是在这里清掉更干净。
+WS_URL_SEGMENTS=""
+_old_ifs="$IFS"; IFS=','
+for _seg in $WS_URL; do
+    # 去前导/尾随空白（IFS 只含逗号，空白不会被自动去掉）
+    _seg="${_seg#"${_seg%%[![:space:]]*}"}"
+    _seg="${_seg%"${_seg##*[![:space:]]}"}"
+    [ -n "$_seg" ] || continue
+    case "$_seg" in
+        ws://*|wss://*) ;;
+        *)
+            IFS="$_old_ifs"
+            echo "错误：WS 地址的每一段都需以 ws:// 或 wss:// 开头（问题段：${_seg}）" >&2
+            exit 1
+            ;;
+    esac
+    case "$_seg" in
+        */ws|*/ws/) ;;
+        *) echo "警告：WS 地址 ${_seg} 看起来不含 /ws 路径，节点可能连不上（节点默认连 <地址>/ws）" >&2 ;;
+    esac
+    WS_URL_SEGMENTS="${WS_URL_SEGMENTS:+${WS_URL_SEGMENTS},}${_seg}"
+done
+IFS="$_old_ifs"
+if [ -z "$WS_URL_SEGMENTS" ]; then
+    echo "错误：WS 地址为空（当前值：${WS_URL}）" >&2
+    exit 1
+fi
+WS_URL="$WS_URL_SEGMENTS"
+
+NODE_ID=$(gen_uuid)
+NODE_KEY=$(gen_token)
+ACCESS_TOKEN=$(gen_token)
+
+# ---------- 公网地址探测（失败不阻断） ----------
+
+detect_ip() {
+    local url="$1" out=""
+    if command -v curl >/dev/null 2>&1; then
+        out=$(curl -fsS -m 5 "$url" 2>/dev/null || true)
+    elif command -v wget >/dev/null 2>&1; then
+        out=$(wget -qO- --timeout=5 "$url" 2>/dev/null || true)
+    fi
+    printf '%s' "$out" | tr -d ' \t\r\n'
+}
+
+is_ipv4() { printf '%s' "$1" | grep -qE '^([0-9]{1,3}\.){3}[0-9]{1,3}$'; }
+is_ipv6() {
+    printf '%s' "$1" | grep -qE '^[0-9A-Fa-f:]+$' || return 1
+    printf '%s' "$1" | grep -q ':' || return 1
+    return 0
+}
+
+IPV4=$(detect_ip "https://4.wsmdn.top/")
+is_ipv4 "$IPV4" || IPV4=""
+IPV6=$(detect_ip "https://6.wsmdn.top/")
+is_ipv6 "$IPV6" || IPV6=""
+
+# 单栈判定：只有一侧能出网就按单栈跑，避免另一协议的拨测全失败刷错误日志
+SINGLE_STACK=""
+STACK_LABEL="双栈"
+if [ -n "$IPV4" ] && [ -z "$IPV6" ]; then
+    SINGLE_STACK="ipv4"
+    STACK_LABEL="IPv4"
+elif [ -z "$IPV4" ] && [ -n "$IPV6" ]; then
+    SINGLE_STACK="ipv6"
+    STACK_LABEL="IPv6"
+fi
+
+# ---------- 版本与下载地址 ----------
+
+fetch_latest_version() {
+    local api="https://api.github.com/repos/nomdn/ipw-cn/releases/latest" raw=""
+    if command -v curl >/dev/null 2>&1; then
+        raw=$(curl -fsS -m 20 "$api" 2>/dev/null || true)
+    else
+        raw=$(wget -qO- --timeout=20 "$api" 2>/dev/null || true)
+    fi
+    printf '%s' "$raw" | grep -o '"tag_name": *"[^"]*"' | head -1 | cut -d'"' -f4
+}
+
+VERSION="$OPT_VERSION"
+if [ -z "$VERSION" ]; then
+    VERSION=$(fetch_latest_version || true)
+fi
+if [ -z "$VERSION" ]; then
+    echo "错误：无法获取最新版本号（GitHub API 不可达或限流）。可用 --version <tag> 指定，例如 --version v3.7.0" >&2
+    exit 1
+fi
+
+DOWNLOAD_URL="https://github.com/nomdn/ipw-cn/releases/download/${VERSION}/${RELEASE_ASSET}"
+if [ -n "$OPT_GH_PROXY" ]; then
+    DOWNLOAD_URL="${OPT_GH_PROXY%/}/${DOWNLOAD_URL}"
+fi
+
+# ---------- 输出节点信息 ----------
+
+print_info() {
+    local dry_note=""
+    if [ "$DRY_RUN" = "true" ]; then
+        dry_note="（dry-run，未实际安装）"
+    fi
+    local ipv4_disp="${IPV4:-检测失败}"
+    local ipv6_disp="${IPV6:-检测失败}"
+    local ipdb_disp="未启用（仅影响 IP 归属地/ASN 类拨测，需要时用 --ipdb 重装启用）"
+    if [ "$OPT_IPDB" = "true" ]; then
+        ipdb_disp="已启用（首次启动后台下载，约 450MB）"
+    fi
+    # WS 地址逐个列出（可能接多个中间件），首个带标签、其余对齐缩进
+    local ws_block=""
+    local _first="true" _u=""
+    local _old_ifs="$IFS"; IFS=','
+    for _u in $WS_URL; do
+        if [ "$_first" = "true" ]; then
+            ws_block="  WS 地址:        ${_u}"
+            _first="false"
+        else
+            ws_block="${ws_block}
+                  ${_u}"
+        fi
+    done
+    IFS="$_old_ifs"
+    cat << EOF
+
+========================================
+ 贡献节点${dry_note}已就绪，请把以下信息提交给管理员
+========================================
+  节点 id:        ${NODE_ID}
+  注册 key:       ${NODE_KEY}
+${ws_block}
+  监听端口:       ${PORTS}
+  单栈模式:       ${STACK_LABEL}
+  access-token:   ${ACCESS_TOKEN}
+  CORS:           不限
+  公网 IPv4:      ${ipv4_disp}
+  公网 IPv6:      ${ipv6_disp}
+  地区-运营商:     请自行填写
+----------------------------------------
+ 中间件 ws-keys（**每个 WS 地址对应的中间件都要登记**，缺一个该条连接会被拒 401）:
+   "${NODE_ID}": "${NODE_KEY}"
+ 中心 / 中间件 api-keys（HTTP 直连本节点时的鉴权）:
+   "${NODE_ID}": "${ACCESS_TOKEN}"
+----------------------------------------
+ 提交邮箱: ${CONTACT_EMAIL}
+ 说明:
+   1. 本节点默认以 WS 方式同时接入上面的中间件（节点主动出站连接），无需公网放行 ${PORTS}/TCP。
+   2. 若接收方希望以 HTTP 方式直连本节点，需放行 ${PORTS}/TCP 且该端口公网可达。
+   3. IP 数据库: ${ipdb_disp}
+----------------------------------------
+ 运维命令（${SCOPE_LABEL}）:
+   状态: ${CTL_CMD} status ${SERVICE_NAME}
+   日志: ${JRN_CMD} ${SERVICE_NAME} -f
+   重启: ${CTL_CMD} restart ${SERVICE_NAME}
+   卸载: ${CTL_CMD} disable --now ${SERVICE_NAME} && rm -f ${SERVICE_FILE} && rm -rf ${INSTALL_DIR}
+ 节点信息备份: ${INSTALL_DIR}/node-info.txt
+========================================
+EOF
+}
+
+# ---------- dry-run：只展示 ----------
+
+if [ "$DRY_RUN" = "true" ]; then
+    echo "架构:     $(uname -m) → ${RELEASE_ASSET}"
+    echo "版本:     ${VERSION}"
+    echo "下载地址: ${DOWNLOAD_URL}"
+    echo "安装目录: ${INSTALL_DIR}"
+    echo "服务名:   ${SERVICE_NAME}"
+    echo "作用域:   ${SCOPE_LABEL}"
+    echo "随机:     端口=${PORTS} 节点id=${NODE_ID}"
+    print_info
+    exit 0
+fi
+
+# ---------- 下载二进制 ----------
+
+echo "正在下载 ${VERSION} / ${RELEASE_ASSET} ..."
+mkdir -p "$INSTALL_DIR"
+if command -v wget >/dev/null 2>&1; then
+    wget -q -O "${INSTALL_DIR}/${BIN_BASE}" "$DOWNLOAD_URL"
+else
+    # -f 让 4xx 直接失败，避免把 GitHub 的 Not Found 页面存成二进制
+    curl -fsSL -o "${INSTALL_DIR}/${BIN_BASE}" "$DOWNLOAD_URL"
+fi
+chmod +x "${INSTALL_DIR}/${BIN_BASE}"
+
+# ---------- 生成 systemd 服务 ----------
+
+# 仅非空项写入，避免空值覆盖节点自身默认值。
+# 值内的双引号 / 反斜杠 / % 必须转义：前两者会破坏 systemd 的引号包裹，
+# % 是 unit 说明符（要写成 %% 才是字面量）。
+ENV_LINES=""
+add_env() {
+    local name="$1" value="$2"
+    [ -n "$value" ] || return 0
+    value="${value//\\/\\\\}"
+    value="${value//\"/\\\"}"
+    value="${value//%/%%}"
+    ENV_LINES="${ENV_LINES}Environment=\"${name}=${value}\"
+"
+}
+add_env PORTS "$PORTS"
+add_env SINGLE_STACK "$SINGLE_STACK"
+add_env WS_URL "$WS_URL"
+add_env NODE_ID "$NODE_ID"
+add_env NODE_KEY "$NODE_KEY"
+add_env ACCESS_TOKEN "$ACCESS_TOKEN"
+add_env IPDB "$OPT_IPDB"
+
+# 用户级 unit 目录（~/.config/systemd/user）默认可能不存在
+mkdir -p "$(dirname "$SERVICE_FILE")"
+
+cat > "$SERVICE_FILE" << EOF
+[Unit]
+Description=Lemon IPW Backend Node
+${UNIT_NETWORK_LINES}
+[Service]
+Type=simple
+${UNIT_USER_LINE}WorkingDirectory=${INSTALL_DIR}
+ExecStart=${INSTALL_DIR}/${BIN_BASE}
+${ENV_LINES}Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=${UNIT_WANTED_BY}
+EOF
+
+# ---------- 启动服务 ----------
+
+sc daemon-reload
+sc enable --now "$SERVICE_NAME" >/dev/null 2>&1 || true
+sleep 2
+if ! sc is-active --quiet "$SERVICE_NAME"; then
+    echo "错误：服务未能启动，最近日志：" >&2
+    jc -u "$SERVICE_NAME" --no-pager -n 20 >&2 || true
+    exit 1
+fi
+
+# 用户级服务默认随最后一个会话结束而停止，注销后要继续跑必须开 linger
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    if loginctl show-user "$(id -un)" -p Linger 2>/dev/null | grep -q 'Linger=yes'; then
+        echo "linger 已启用：用户注销后服务继续运行"
+    elif loginctl enable-linger "$(id -un)" >/dev/null 2>&1; then
+        echo "已启用 linger：用户注销后服务继续运行"
+    else
+        echo "提示：未能自动启用 linger，注销后服务会被停止。请手动执行：" >&2
+        echo "      sudo loginctl enable-linger $(id -un)" >&2
+    fi
+fi
+
+# ---------- 落一份信息备份（节点标识随机，记不住） ----------
+
+{
+    echo "node_id=${NODE_ID}"
+    echo "node_key=${NODE_KEY}"
+    echo "access_token=${ACCESS_TOKEN}"
+    echo "ws_url=${WS_URL}"
+    echo "port=${PORTS}"
+    echo "single_stack=${SINGLE_STACK:-双栈}"
+    echo "service=${SERVICE_NAME}"
+    echo "install_dir=${INSTALL_DIR}"
+    echo "version=${VERSION}"
+} > "${INSTALL_DIR}/node-info.txt"
+chmod 600 "${INSTALL_DIR}/node-info.txt"
+
+# 本地存活自检（只打本机回环，不依赖接收方是否已登记）
+LOCAL_CHECK="失败"
+if command -v curl >/dev/null 2>&1; then
+    if curl -fsS -m 5 "http://127.0.0.1:${PORTS}/" >/dev/null 2>&1; then
+        LOCAL_CHECK='正常（{"status":"ok"}）'
+    fi
+fi
+echo "本地自检: ${LOCAL_CHECK}"
+
+print_info
@@ -22,20 +22,40 @@
 - `dnssec-server`：**DNSSEC 专用** DNS 服务器（同样支持主从逗号分隔）；留空则沿用 `dns-server`；`dns-server` 与 `dnssec-server` **都留空时自动探测系统 DNS** 兜底
 - `block-private-ips`：SSRF 防护开关（拒绝出站连接内网/私有地址；探测目标命中私有网段时直接返回伪造结果，禁止跨跳重定向）
 - `single-stack`：单栈模式，`ipv4` / `ipv6` / 留空（双栈）。声明单栈的节点跳过另一栈的探测（直接返回 `Skipped due to SINGLE_STACK=...`），EdgeOne / Vercel 等 IPv4-only 环境建议设为 `ipv4`
- `ipdb`：IP 数据库开关。**不配置时默认启用**（首次启动自动下载约 450MB，之后每 24h 更新）；仓库的 `setting.json.example` 里显式写为 `"false"`，即**示例配置是关闭状态**——关闭后不加载任何数据库，`/v1/location`、`/v1/asn` 路由不注册，适合只做网络拨测的轻量节点
+- `ipdb`：IP 数据库开关。**不配置时默认启用**（首次启动自动下载约 450MB，之后每 24h 更新）；仓库的 `setting.json.example` 里显式写为 `false`，即**示例配置是关闭状态**——关闭后不加载任何数据库，`/v1/location`、`/v1/asn` 路由不注册，适合只做网络拨测的轻量节点
 - `cors`：允许的请求来源（逗号分隔）
 - `trusted-proxies`：可信代理 IP/CIDR（逗号分隔，如 `"10.0.0.0/8,173.245.48.0/20"`）。配置后 `ClientIP` 与 `/v1/location` 归属地接口只信任这些代理转发的 `X-Forwarded-For`，直连公网的节点可防止访客伪造 XFF；**留空保持默认行为（信任所有代理，XFF 可被伪造）**
 - `access-token`：API 访问令牌，留空则不启用鉴权。**它同时是 HTTP 管理面的开关**：留空时 `/v1/config`、`/v1/ota` 整组返回 `403`，只能走 WS 通道管理
 - `gh-proxy`：GitHub 下载代理前缀（如 `"https://ghproxy.com/"`），用于 IP 数据库拉取与 OTA 下载加速；留空直连
 - `node-ota`：OTA 开关，缺省 `true`（允许收集中心下发）。设为 `false` 时节点拒绝一切 OTA 指令并回传原因，适合只读文件系统 / 编排托管（升级走各自部署渠道）的部署。**支持运行时热改**（`PATCH /v1/config` 或 WS `config` 下发即时生效，改后按新值判定后续 OTA 指令）
+- `access-log`：访问日志开关，缺省 `true`（每个请求输出一条 `http` 记录：method / path / status / latency_ms / ip）。设为 `false` 后不再输出访问日志，**适合高吞吐节点**——访问日志是每请求一次同步写，压测中即便业务逻辑极轻（`/` 健康检查）吞吐也会被它压住。关闭后 panic 兜底与其余日志不受影响，仍会记录 500 与堆栈。**支持运行时热改**（`PATCH /v1/config` 或 WS `config` 下发即时生效，无需重启）
 - `ws-url`：WS 通道地址——接入独立中间件的 WebSocket 地址（如 `"wss://middleware-1.api-ipw.wsmdn.top/ws"`，须含 `wss://` 前缀与 `/ws` 路径）；支持**逗号分隔多个中间件，同时连接全部（多活）**，任一断开只重连自己，不影响其他连接；留空 = 不启用 WS 客户端，走原 HTTP 接口
 - `node-id`：WS 节点 id（与中间件 `api-keys`/`ws-keys` 键、前端配置的节点 `id` 一致；建议用 UUID 唯一标识）
 - `node-key`：WS 注册 key（与中间件 `ws-keys[节点id]` 一致；**必填**——节点未配置该 key 时中间件拒绝注册并返回 401）
 - `report-url`：**数据上报收集中心** HTTP 基址（如 `"https://collector.example.com"`，即 ipw-boce 中间件）。节点把自身观测的统计/拨测按 `report-interval-seconds` 周期上报；`ws-url` 已启用时优先走 WS `report` 消息（所有已连接中间件广播），WS 未启用或全部掉线时 HTTP POST 到 `<report-url>/report` 兜底；远端配置可覆盖（在 `remote-ignore-config` 里加上 `report-url` 可禁止覆盖）
 - `report-token`：收集中心 `/report` 鉴权 token（与中间件 `report-token` 配置一致）；属凭据类键，GET 快照里遮蔽为 `***`；**不随远端配置覆盖**（硬编码保护，清单见本页末的「远端配置」一节）
 - `report-interval-seconds`：上报周期秒，缺省 15
+- `max-response-body`：单次拨测可读的响应体上限，**按解压后大小**算，缺省 `32MB`（33554432 字节）；支持裸数字与 `K`/`M`/`G` 后缀（`32MB` / `8M` / `1g` / `8MiB` 均可，大小写不敏感）。`detail` / `speed` / `ssl` 只需要一个字节数，正常网页远小于默认值；超过上限**直接返回错误，而不是截断上报**——报一个"截断后的大小/速度"比报错更误导人。**支持运行时热改**（`PATCH /v1/config` 下发即应用到出站客户端）
+- `memory-limit`：Go 运行时的**软**内存上限（等价 `GOMEMLIMIT`），字节数，写法同上；**留空（=0）表示自动取容器内存限额的 90%**，探测不到容器限额就不设置、保持 Go 默认 GC 行为。不设时 Go 只按 `GOGC` 比例回收，够不到突增，小内存机器上堆会一路涨到被内核 OOM kill，中间没有减速带。**软上限不是硬闸**：必要时运行时仍会越过它，只是付出更多 GC 代价。**支持运行时热改**

-以上字段均可用环境变量覆盖（`PORTS` / `SINGLE_STACK` / `DNS_SERVER` / `DNSSEC_DNS_SERVER` / `BLOCK_PRIVATE_IPS` / `IPDB` / `CORS` / `TRUSTED_PROXIES` / `GH_PROXY` / `ACCESS_TOKEN` / `WS_URL` / `NODE_ID` / `NODE_KEY` / `NODE_OTA` / `REPORT_URL` / `REPORT_TOKEN` / `REPORT_INTERVAL_SECONDS`）。需要从远端拉取配置时，设置 `remote-config-url` 或环境变量 `REMOTE_CONFIG_URL`（优先级：远端 > 环境变量 > setting.json）；`remote-ignore-config` 对应的环境变量为 `REMOTE_IGNORE_CONFIG`（JSON 数组字符串）。
+以上字段均可用环境变量覆盖（`PORTS` / `SINGLE_STACK` / `DNS_SERVER` / `DNSSEC_DNS_SERVER` / `BLOCK_PRIVATE_IPS` / `ACCESS_LOG` / `IPDB` / `CORS` / `TRUSTED_PROXIES` / `GH_PROXY` / `ACCESS_TOKEN` / `WS_URL` / `NODE_ID` / `NODE_KEY` / `NODE_OTA` / `REPORT_URL` / `REPORT_TOKEN` / `REPORT_INTERVAL_SECONDS` / `MAX_RESPONSE_BODY` / `MEMORY_LIMIT`）。需要从远端拉取配置时，设置 `remote-config-url` 或环境变量 `REMOTE_CONFIG_URL`（优先级：远端 > 环境变量 > setting.json）；`remote-ignore-config` 对应的环境变量为 `REMOTE_IGNORE_CONFIG`（JSON 数组字符串）。
+
+> [!TIP]
+> 后端字段共 22 个，`src/setting.json.example` 只列**最小可用集**（11 个：端口 / 代理 / 单栈 / DNS / IP 库 / CORS / 令牌 / WS 身份）——其余按需加，完整定义以本页为准。
+
+<a id="bool-switches"></a>
+
+> [!NOTE]
+> **四个开关（`ipdb` / `block-private-ips` / `node-ota` / `access-log`）共用一套字面值口径**（忽略大小写与首尾空白）：
+>
+> - 开：`true` / `1` / `yes` / `on` / `enable` / `enabled`
+> - 关：`false` / `0` / `no` / `off` / `disable` / `disabled`
+>
+> 不配置（空值）时各用各的默认值（`block-private-ips` / `node-ota` / `access-log` / `ipdb` 都缺省**开**）。JSON 里写布尔 `true` 或字符串 `"true"` 均可，数字 `1` / `0` 也可以 —— 四条来源（`setting.json` / 环境变量 / `PATCH /v1/config` / 远端下发）会先归一成同一张字面量表再判定，所以布尔与字符串的结果必然一致。
+>
+> **认不出来的值不再静默当成"开"**：启动阶段告警并按默认值处理；`PATCH /v1/config` 与远端下发会把它计入应答的 `unknown` 并保留原值，便于发现拼错的键值。
+>
+> 历史差异（升级时注意）：旧版本里只有 `node-ota` 认 `yes`/`no`/`off`，在 `ipdb` / `block-private-ips` / `access-log` 上写 `no` / `off` 会被当成**开**，`ipdb` 还大小写敏感（`"False"` 也是开）。现在四个开关统一按上表判定。

 ### 运行时配置管理

@@ -51,7 +71,7 @@

 - **凭据类键不回显明文**：`access-token` / `node-key` / `report-token` 在快照里是 `***`。下发时必须剔除这些键，否则会把真值覆盖成三个星号（收集中心控制台已自动剔除）。
 - **凭据类键中 `access-token` / `report-token` 不受远端配置影响**：它们被硬编码进节点侧的保护名单（`configRemoteProtectedKeys`），远端配置里写了也会被跳过，并在应答 `protectedIgnored` 与日志中如实回报；本地 PATCH 不受此限。原因见本页末的「远端配置」一节。
- **节点不自行重启**：`port` / `cors` / `ipdb` / `report-interval-seconds` / `trusted-proxies` / `node-id` / `node-key` / `access-token` 是启动期固定的，改动后在应答 `restartRequired` 里如实列出，但**不会自动重启**；只有"值真的变了"才报，避免每次全量下发都误报。**`ws-url` 是例外，热生效**（控制器按新地址多退少补）；`dns-server` / `dnssec-server` / `block-private-ips` / `single-stack` / `node-ota` 每次消费重读，同样即时生效。
+- **节点不自行重启**：`port` / `cors` / `ipdb` / `report-interval-seconds` / `trusted-proxies` / `node-id` / `node-key` / `access-token` 是启动期固定的，改动后在应答 `restartRequired` 里如实列出，但**不会自动重启**；只有"值真的变了"才报，避免每次全量下发都误报。**`ws-url` 是例外，热生效**（控制器按新地址多退少补）；`dns-server` / `dnssec-server` / `block-private-ips` / `single-stack` / `node-ota` / `access-log` / `max-response-body` / `memory-limit` 每次消费重读，同样即时生效。
 - **内存改动会被重启顶掉**：节点侧优先级为 远端 > 环境变量 > `setting.json`。只 PATCH 内存（或 `persist` 写本地文件）时，重启后仍可能被 ENV 顶掉；要长期生效应 **`refresh`**（改远端配置）或把改动合并进托管配置。

 > [!NOTE]
@@ -103,6 +103,10 @@ node .output/server/index.mjs   # 默认监听 3000 端口
 - **所需 Secrets**：`CLOUDFLARE_API_TOKEN`、`CLOUDFLARE_ACCOUNT_ID`
 - **注意**：工作流设置了 `NITRO_PRESET: cloudflare_module`

+## 缓存
+
+缓存头不在应用侧设置，全部交由前置 CDN（EdgeOne）控制。
+
 ## 常见问题

 - **部署后接口 403 / 跨域**：检查后端 `cors` 配置（独立中间件见 `middleware-go/setting.json` 的 `cors` 字段，逗号分隔允许域名）；服务端转发请求不带 `Origin`，浏览器直接调用才受 CORS 限制。
@@ -839,8 +839,8 @@ packages:
  vfile@6.0.3:
    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}

-  vite@5.4.14:
-    resolution: {integrity: sha512-EK5cY7Q1D8JNhSaPKVK4pwBFvaTmZxEnoKXLG/U9gmdDcihQGNzFlgIvaxezFR4glP1LsuiedwMBqCXH3wZccA==}
+  vite@5.4.21:
+    resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==}
    engines: {node: ^18.0.0 || >=20.0.0}
    hasBin: true
    peerDependencies:
@@ -1302,9 +1302,9 @@ snapshots:

  '@ungap/structured-clone@1.3.3': {}

-  '@vitejs/plugin-vue@5.2.1(vite@5.4.14)(vue@3.5.41)':
+  '@vitejs/plugin-vue@5.2.1(vite@5.4.21)(vue@3.5.41)':
    dependencies:
-      vite: 5.4.14
+      vite: 5.4.21
      vue: 3.5.41

  '@vue/compiler-core@3.5.41':
@@ -1733,7 +1733,7 @@ snapshots:
      '@types/unist': 3.0.3
      vfile-message: 4.0.3

-  vite@5.4.14:
+  vite@5.4.21:
    dependencies:
      esbuild: 0.21.3
      postcss: 8.5.26
@@ -1806,7 +1806,7 @@ snapshots:
      '@shikijs/transformers': 2.1.0
      '@shikijs/types': 2.1.0
      '@types/markdown-it': 14.1.2
-      '@vitejs/plugin-vue': 5.2.1(vite@5.4.14)(vue@3.5.41)
+      '@vitejs/plugin-vue': 5.2.1(vite@5.4.21)(vue@3.5.41)
      '@vue/devtools-api': 7.7.10
      '@vue/shared': 3.5.41
      '@vueuse/core': 12.4.0
@@ -1815,7 +1815,7 @@ snapshots:
      mark.js: 8.11.1
      minisearch: 7.2.0
      shiki: 2.1.0
-      vite: 5.4.14
+      vite: 5.4.21
      vue: 3.5.41
    optionalDependencies:
      postcss: 8.5.26
@@ -1,10 +1,24 @@
 <script setup lang="ts">
-import { computed, onMounted, onBeforeUnmount, ref } from 'vue';
+import { computed, nextTick, onMounted, onBeforeUnmount, ref } from 'vue';
 import { useDark, useToggle } from '@vueuse/core';
 import { Moon, Sunny, Expand } from '@element-plus/icons-vue';
 import { config } from '../config/index';

-const isNarrow = ref(false);
+// ==================== 窄屏判定（水合前就必须定下来） ====================
+// 为什么不能等到 onMounted 才算：SSR 不知道视口宽度，只能按宽屏输出 ——
+// 于是整条桌面版顶栏菜单（10 个条目 + 分隔线 + 3 个下拉）会被下发给手机；
+// 水合时 isNarrow 还是 false，手机就先把这一整套水合一遍
+// （实测 375×812：header-menu 区域 268 次 DOM 变更、70 次事件绑定），
+// 紧接着 onMounted 把它改成窄屏、再整棵销毁重建 —— 这一整轮纯属白干。
+// 所以改成「服务端按请求头判定、客户端直接沿用服务端序列化下来的结论」，
+// 两边输入一致 ⇒ 结论一致 ⇒ 水合期不产生任何分歧，桌面上仍是原来的形态。
+// 权威值依旧由 onMounted 的 matchMedia 覆盖，管「桌面窗口被拖窄」这类请求头判不出的情形。
+//
+// 注意：**不要**在客户端重新嗅探 navigator.userAgent。SSR 页两边大概率巧合一致，
+// 但预渲染页没有请求头（服务端恒判宽屏），客户端一嗅探就必然分叉 ——
+// 实测那会让整个 /doc/** 在真手机上水合失配、Nuxt 直接渲染 500 页。
+// 判定逻辑与文档见 app/composables/useShellNarrow.ts。
+const isNarrow = useShellNarrow()
 let mediaQueryList: MediaQueryList | null = null;
 const drawer = ref(false);

@@ -90,9 +104,24 @@ const hidden = computed<Array<NavItem | NavGroup>>(
    entry.kind !== 'divider' && viewportWidth.value < entry.minWidth),
 )

+// EP 的 Menu.init() 会在挂载时（以及菜单项集合变化时）遍历顶栏 <ul> 的**每个直接子元素**、
+// 统一写 tabindex="0" —— 连纯装饰的分隔条也不放过。调用栈实测：
+//   Menu.init → Array.forEach → new MenuItem(el).init → setAttribute('tabindex','0')
+// 分隔条是 aria-hidden 的装饰元素，留着 tabindex="0" 会被 axe 判为 aria-hidden-focus
+// （"Focusable content should have tabindex=-1 or be removed from the DOM"）——
+// 这一条比它替换掉的 aria-required-attr 更靠后，所以必须显式改回去。
+// 改的时机：子组件 mounted 早于父组件，onMounted 里 EP 已经 init 完；
+// 但要等 DOM 更新落定 —— updateViewport() 会改 visible、让 el-menu 重渲染并再 init 一遍。
+function fixDividerTabindex() {
+  document.querySelectorAll('.menu-divider').forEach((el) => {
+    el.setAttribute('tabindex', '-1')
+  })
+}
+
 // 实时同步视口宽度（resize 触发，驱动折叠）
 function updateViewport() {
  viewportWidth.value = window.innerWidth
+  nextTick(fixDividerTabindex)
 }
 let umamiScript: HTMLScriptElement | null = null
 useHead({
@@ -123,13 +152,22 @@ onMounted(() => {
    window.removeEventListener('resize', updateViewport);
  });

-  if (!umamiScript && config.umamiScriptUrl) {
+  // 统计脚本延迟到浏览器空闲再注入：umami 源响应慢（实测 ~1.6s），
+  // 挂在 onMounted 里会和首页首屏的拨测请求抢慢速网络的带宽，
+  // 拖累 Speed Index；统计本身不需要抢首屏前的任何窗口。
+  const loadUmami = () => {
+    if (umamiScript || !config.umamiScriptUrl) return
    umamiScript = document.createElement('script')
    umamiScript.src = config.umamiScriptUrl
    umamiScript.async = true
    umamiScript.setAttribute('data-website-id', config.umamiWebsiteId)
    document.head.appendChild(umamiScript)
  }
+  if ('requestIdleCallback' in window) {
+    requestIdleCallback(loadUmami, { timeout: 4000 })
+  } else {
+    setTimeout(loadUmami, 2000)
+  }
 })
 </script>

@@ -177,12 +215,25 @@ onMounted(() => {
      :ellipsis="false"
      
    >
-    <el-menu-item index="0" aria-label="返回首页">
+    <!-- 宽屏不给 aria-label：这个 <li> 里有可见文本（右侧的 h2 站名），而 axe 的
+         label-content-name-mismatch 要求 aria-label 必须把可见文本包含进去 ——
+         写死「返回首页」只会被判不匹配（Lighthouse 桌面独有项，权重 0 不扣分，但语义是错的）。
+         窄屏 h2 被 v-if 隐藏、img 的 alt 留空、el-icon 也没有文本 ⇒ 那时才需要
+         aria-label 兜底，否则承载 role="menuitem" 的 <li> 就没有可访问名（aria-command-name）。
+         里面那个 <router-link> 同理（它自己也是一个可访问名有冲突的目标），
+         宽屏靠 h2 的「柠檬味ipw.cn」当名字，窄屏才补「返回首页」。 -->
+    <el-menu-item index="0" :aria-label="isNarrow ? '返回首页' : undefined">
      <el-icon v-if="isNarrow" @click="drawer = !drawer"><Expand /></el-icon>
-      <router-link to="/" aria-label="返回首页">
+      <router-link to="/" :aria-label="isNarrow ? '返回首页' : undefined">
        <!-- alt 留空是有意的：logo 属装饰图，可访问名由外层链接提供。
-             若把 alt 写成站名，宽屏下会与旁边的 h2 一起被读两遍。 -->
-        <el-image src="/favicon.svg" alt="" style="margin-top: 20px;" /> 
+             若把 alt 写成站名，宽屏下会与旁边的 h2 一起被读两遍。
+             这里用原生 <img> 而不是 el-image：el-image 默认 lazy，SSR 只输出一个
+             `.el-image__placeholder` 空壳，真正的 <img> 要等客户端水合后由
+             IntersectionObserver 插进去 ⇒ logo 在首屏 HTML 里不存在（无 JS 时永不显示，
+             有 JS 时也要闪一下）。原生 <img> 直接进 HTML，还顺带省掉 el-image
+             及其 image-viewer 的样式。宽高属性声明固有比例，显示宽度由下文
+             :deep(.el-menu-item a img) 定为 50px。 -->
+        <img src="/favicon.svg" alt="" width="50" height="50" style="margin-top: 20px;" />
        <h2 style="display: inline-block; margin-left: 10px" v-if="!isNarrow">{{ config.siteName }}</h2>
      </router-link>
    </el-menu-item>
@@ -199,7 +250,13 @@ onMounted(() => {
          <router-link :to="child.to"><p class="menu-item-text">{{ child.label }}</p></router-link>
        </el-menu-item>
      </el-sub-menu>
-      <el-divider v-else style="margin-top: 20px;height: 1.2em;" direction="vertical"/>
+      <!-- 分组之间的竖分隔条。原来是 <el-divider direction="vertical">，但它在客户端水合后
+           会被 EP 补上 tabindex="0"（SSR HTML 里干净、没有这个属性），于是 axe 把
+           role="separator" 当成「可聚焦控件」并要求它带 aria-valuenow —— 这就是桌面端
+           aria-required-attr 那一条（Lighthouse 权重 10，是桌面 a11y 掉 12 分里的最大单项）。
+           换成 aria-hidden 的原生 <span>：装饰元素不参与焦点，也不会被 EP 改写属性。
+           视觉与 .el-divider--vertical 等价，数值见下方 .menu-divider 的注释。 -->
+      <span v-else class="menu-divider" aria-hidden="true"></span>
    </template>
    <!-- 折叠项：统一收进「更多」子菜单（分组用 el-menu-item-group 保留组名） -->
    <el-sub-menu v-if="hidden.length" index="more">
@@ -236,12 +293,19 @@ onMounted(() => {
       且窄屏下与侧栏抽屉的可滚动区域互相挤压。 -->
  <footer v-if="!isDocRoute">
    <div class="one-line">
-      Copyright © nomdn & IP 查询 2026  | <img src="/ipv6-s1.svg" alt="IPv6 相关标识"/> | <img src="/ssl-s1.svg" alt="SSL 相关标识"/> | All right reserved
+      <!-- 这两张 svg 补上 width/height 属性（= 各自的固有尺寸 190×36 / 85×36）：
+           浏览器要在图下载完之前就知道占位比例，否则会先把整行按 0 高度排一遍、
+           图到了再重排（Lighthouse 的 unsized-images 就是这条）。
+           属性只声明固有比例，不改变显示尺寸：桌面端本来就是按固有尺寸渲染，
+           窄屏由 style.css 的 `footer .one-line img { height:1.2em; width:auto }` 接管。 -->
+      Copyright © nomdn & IP 查询 2026  | <img src="/ipv6-s1.svg" alt="IPv6 相关标识" width="190" height="36"/> | <img src="/ssl-s1.svg" alt="SSL 相关标识" width="85" height="36"/> | All right reserved
    </div>
    <div class="one-line">
      <a v-if="config.ICP" href="https://beian.miit.gov.cn/" target="_blank" rel="noreferrer" >{{ config.ICP }}</a>
      <span v-if="config.ICP">&nbsp;|&nbsp;</span>
-      <el-image v-if="config.GongAn" style="height: 1em; width: 1em;" src="/备案图标.png" />
+      <!-- 同上：原生 <img> 而非 el-image（1em 见方的小图标，用不着 lazy/预览器）。
+           显示尺寸由行内 style 定死；width/height 属性只声明固有比例（36×40），防抖动。 -->
+      <img v-if="config.GongAn" src="/备案图标.png" alt="" width="36" height="40" style="height: 1em; width: 1em;" />
      <a v-if="config.GongAn" :href="'https://beian.mps.gov.cn/#/query/webSearch?code=' + cleanChineseCharacters(config.GongAn)" target="_blank" rel="noreferrer" >{{ config.GongAn }}</a>
      <span v-if="config.GongAn">&nbsp;|&nbsp;</span>
      <a href="https://www.china-ipv6.cn/" target="_blank" rel="noreferrer" >国家IPv6发展监测平台</a>
@@ -288,10 +352,27 @@ onMounted(() => {
  margin-bottom: 20px;
  
 }
+/* 顶栏分组之间的竖分隔条（template 里那个 aria-hidden 的 span）。
+   数值抄自 element-plus 的 .el-divider--vertical：1px 左边框、1.2em 高、
+   margin 左右各 8px、vertical-align: middle；再加上原来行内 style 的 margin-top: 20px
+   与 height: 1.2em，保证与替换前的排布一致。 */
+.menu-divider {
+  display: inline-block;
+  position: relative;
+  width: 1px;
+  height: 1.2em;
+  margin: 20px 8px 0;
+  vertical-align: middle;
+  border-left: 1px solid var(--el-border-color);
+}
 </style>
 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
+  /* 正文/页脚链接色：亮色白底需 ≥4.5:1（axe color-contrast 审计线）。
+     #299764 白底只有 3.68:1，加深到 #1d7a4a = 5.34:1，留足余量。
+     主题色（按钮/高亮等 --el-color-primary 消费方）保持 #299764 不动，只分流链接。 */
+  --link-color: #1d7a4a;
 }
 html.dark {
  /* 暗色模式下根元素的文字色与页面底色。
@@ -300,9 +381,10 @@ html.dark {
     `html.dark[data-v-xxxx]` —— 整条规则永不匹配，底色只能靠浏览器的 color-scheme 兜底。 */
  color: rgba(255, 255, 255, 0.87);
  background-color: #242424;
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
+  /* 暗底 #242424 上 #299764 对比 ~4.2:1，且再加深只会更差 —— 暗色链接保持原色 */
+  --link-color: #299764;
 }
-
 /* Drawer 内部链接占满一行。
   注意用直接子选择器（> a）：文档菜单（DocMenu）里的 <a> 嵌在 el-menu-item 里，
   不能被这套「整行大按钮」规则吃掉，否则菜单项会变成上下带 1em 内边距的块。
@@ -370,7 +452,7 @@ html.dark {
 /* 窄屏（≤768px，与 script 中 isNarrow 的 matchMedia 断点一致）：
   在水合前由 CSS 兜底隐藏宽屏菜单项，避免窄屏设备闪现宽屏布局 */
@media (max-width: 768px) {
-  .el-menu--horizontal > .el-divider {
+  .el-menu--horizontal > .menu-divider {
    display: none !important;
  }
  .el-menu--horizontal > .el-menu-item[index="1"],
@@ -392,6 +474,39 @@ html.dark {
  --el-menu-bg-color: transparent !important;
 }

+/* 顶栏菜单项的点击目标：让内层 <a> 撑满整个 <li>。
+   axe 的 target-size（WCAG 2.2 的 2.5.8，24×24 最小目标）会把 <li role="menuitem">
+   减掉内层 <a> 之后剩下的「侧翼」算成被遮挡的空间：EP 默认给 li 左右各 20px 内边距，
+   而 <a> 只占中间 97px 宽，于是报
+   "partially obscured (smallest space is 20px by 59px)" —— 桌面 7 条、权重 7。
+   有两条路：① 把 --el-menu-base-level-padding 提到 >24px —— 顶栏整体就变宽，
+   1350px 下直接横向溢出 45px（各档折叠阈值还得跟着重算）；② 让 <a> 撑满 li —— 本条。
+   选②：li 宽度、文字位置、分隔条位置与改动前【逐像素一致】（CDP 量 rect 比对过），
+   可点区域却从 97×59 变成整项 137×59，远超 24×24。
+   - flex + align-items:center 是为了复现原来 inline 盒子靠 line-height 得到的垂直居中
+     （logo 的 img 顶边仍在 li 顶 +4.5px 处，改完不位移）；
+   - 负 margin 抵消 li 的左右内边距，与 padding 取同一个变量，改内边距时不会脱节；
+   - height:100% 成立是因为 EP 给 .el-menu-item 写了确定的 height(--el-menu-item-height)。
+   必须写在这个【非 scoped】块里：el-menu 是 fragment 根，scope 属性在它自己身上而不是
+   祖先，<style scoped> 里的 :deep(.el-menu--horizontal) 选不到它。
+   只作用于顶栏这条 ul —— sub-menu 的弹层被 teleport 到 body，跑不到这个选择器下。 */
+.el-menu--horizontal > .el-menu-item > a {
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  height: 100%;
+  margin: 0 calc(-1 * var(--el-menu-base-level-padding));
+  padding: 0 var(--el-menu-base-level-padding);
+}
+
+/* logo 那个 <a> 单独放开 overflow（选择器多一层 :nth-child(1)，免得靠书写顺序
+   去压 scoped 块里 :deep(.el-menu-item a) 的 overflow:hidden）。
+   它的 img 带 20px 上下外边距、总高 90px 塞在 59px 的 li 里：原来 <a> 是 inline
+   元素、overflow 本来就不生效才没被裁；上面改成 flex 后若不显式放开，logo 会被切掉。 */
+.el-menu--horizontal > .el-menu-item:nth-child(1) > a {
+  overflow: visible;
+}
+
 .el-menu--horizontal > .el-menu-item:nth-child(1) {
  margin-right: auto;
 }
@@ -0,0 +1,34 @@
+/**
+ * 顶栏 / 抽屉「宽屏还是窄屏」的唯一判定入口（服务端算一次，客户端沿用）。
+ *
+ * 为什么客户端不自己嗅探 navigator.userAgent：
+ * SSR 出的 HTML 是跟着【服务端】的判定走的。客户端若各算各的，只要两边结论不一致，
+ * Vue 水合就会整棵树失配 —— 实测在预渲染的 /doc/** 上是直接抛
+ * `Cannot read properties of null (reading 'nodeType')`，然后被 Nuxt 渲染成 500 页
+ * （真手机打开文档站必然复现：预渲染时没有请求头 ⇒ 服务端恒判宽屏）。
+ * 把服务端的判定序列化进 payload 当客户端的初值，首帧 vdom 与 HTML 必然一致；
+ * 顺带还免疫「CDN 把桌面版缓存回给手机」——那种情况下客户端也会乖乖按 HTML 走宽屏。
+ *
+ * 权威值仍由 app.vue 的 onMounted 用 matchMedia 覆盖，管「桌面窗口被拖窄」这类
+ * 请求头判不出的情形。窄屏判定是全局共享状态（useState），文档页据此决定要不要
+ * 渲染侧栏，所以两边读的必须是同一个 ref。
+ */
+const CRAWLER_RE =
+  /bot|crawler|spider|slurp|bingbot|baiduspider|yandex|duckduckbot|facebookexternalhit|preview/i
+
+export function uaIsNarrow(ua: string, chMobile?: string) {
+  if (!ua && !chMobile) return false // 两个都拿不到（含预渲染）：按宽屏，与改造前一致
+  if (CRAWLER_RE.test(ua)) return false // 抓取端一律宽屏，否则顶栏导航链接会从 HTML 里消失
+  if (chMobile) return chMobile === '?1' // Chromium 的 Client Hint，最准
+  return /Android|iPhone|iPod|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile|Mobile/i.test(ua)
+}
+
+export function useShellNarrow() {
+  // 只有服务端拿得到请求头；客户端分支只为类型与「init 被意外调用」兜底。
+  const headers: Record<string, string | undefined> = import.meta.server
+    ? useRequestHeaders(['user-agent', 'sec-ch-ua-mobile'])
+    : {}
+  return useState<boolean>('ipw-shell-narrow', () =>
+    uaIsNarrow(headers['user-agent'] || '', headers['sec-ch-ua-mobile']),
+  )
+}
@@ -9,10 +9,10 @@ html.dark .markdown-body {
  /* GitHub 暗色主题的核心颜色 */
  --color-fg-default: #e6edf3;
  --color-fg-muted: #8b949e;
-  --color-fg-accent: #3EAF7C;
+  --color-fg-accent: #299764;
  --color-bg-default: #242424;
  --color-bg-muted: #080707;
-  --color-bg-accent: #3EAF7C;
+  --color-bg-accent: #299764;
  --color-border-default: #242424;
  --color-border-muted: #242424;
  
@@ -182,14 +182,14 @@ function getStatusClass(status: string): string {
          <tr v-if="result.dbip_asn?.asn">
            <td class="table-label">DB-IP ASN</td>
            <td class="table-value">
-              AS{{ result.dbip_asn.asn }}
+              {{ result.dbip_asn.asn }}
              <span v-if="result.dbip_asn.org" style="color: #999; font-size: 0.9em;">{{ result.dbip_asn.org }}</span>
            </td>
          </tr>
          <tr v-if="result.ip2location_asn?.asn">
            <td class="table-label">IP2Location ASN</td>
            <td class="table-value">
-              AS{{ result.ip2location_asn.asn }}
+              {{ result.ip2location_asn.asn }}
              <span v-if="result.ip2location_asn.as" style="color: #999; font-size: 0.9em;">{{ result.ip2location_asn.as }}</span>
            </td>
          </tr>
@@ -261,10 +261,10 @@ function getStatusClass(status: string): string {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -201,7 +201,8 @@ const doc = page.value;
        v-model="tmpDomain" 
        placeholder="请输入域名（如：example.com）" 
      />
-      <el-select v-model="recordType" style="width: 150px;" class="custom-height-select">
+      <!-- aria-label 落到 EP select 内部的原生 input 上，否则 Lighthouse 的 label 审计必挂 -->
+      <el-select v-model="recordType" style="width: 150px;" class="custom-height-select" aria-label="DNS 记录类型">
        <el-option 
          v-for="item in recordTypes" 
          :key="item.value" 
@@ -297,7 +298,7 @@ const doc = page.value;
 }

 .markdown :deep(a) {
-  color: #3EAF7C !important;
+  color: #299764 !important;
  font-size: 1.3em;
  text-decoration: none
 }
@@ -305,11 +306,11 @@ const doc = page.value;

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 .el-icon {
@@ -284,10 +284,10 @@ async function getUserIP() {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -1,6 +1,10 @@
 <script setup lang="ts">
 import { getDocMeta } from '../../../config/doc'

+// 窄屏下这条侧栏被 CSS 隐藏（导航在顶栏抽屉里），但照样要花钱水合 ——
+// 详见 app/pages/doc/index.vue 的同名注释。
+const isNarrow = useShellNarrow()
+
 const route = useRoute();

 const path = computed(() => route.path)
@@ -18,7 +22,7 @@ useHead({
    <div class="box">
        <!-- 文档导航只有一份实现（app/components/DocMenu.vue）。
             宽屏：就是这条左侧固定侧栏；窄屏：本侧栏隐藏，改由顶部抽屉菜单承载 -->
-        <DocMenu class="sidebar-menu" />
+        <DocMenu v-if="!isNarrow" class="sidebar-menu" />
        <div class="content">
            <div class="markdown-body" v-if="page">
                <div v-html="page" />
@@ -1,6 +1,13 @@
 <script setup lang="ts">
 import { getDocMeta } from '../../../config/doc'

+// 窄屏（≤768px）下这条侧栏被 CSS 整个隐藏，导航改由顶栏抽屉承载。
+// 但「只是藏起来」不等于不花钱：Vue 依旧会把整棵 40 项的 el-menu 水合一遍
+// （实测手机端 doc-sidebar 区域 53 次事件绑定）。所以直接按判定结果不渲染。
+// 这里用的是全局共享的窄屏状态（服务端按请求头判定并随 payload 下发），
+// 与 app.vue 同一份 —— 首帧与服务端 HTML 一致，不会有水合分歧。
+const isNarrow = useShellNarrow()
+
 const { data: page } = await useAsyncData('doc-index', () =>
  $fetch('/api/markdown/doc/index')
 )
@@ -18,7 +25,7 @@ useHead({
    <div class="box">
        <!-- 文档导航只有一份实现（app/components/DocMenu.vue）。
             宽屏：就是这条左侧固定侧栏；窄屏：本侧栏隐藏，改由顶部抽屉菜单承载 -->
-        <DocMenu class="sidebar-menu" />
+        <DocMenu v-if="!isNarrow" class="sidebar-menu" />
        <div class="content">
            <div class="markdown-body" v-html="doc"></div>
        </div>
@@ -24,6 +24,32 @@ useHead({
    { name: 'twitter:card', content: 'summary_large_image' },
  ],
  script: [
+    {
+      // —— IP 探测提前到 HTML 解析期（LCP 优化）——
+      // 原来三个探测请求在 onMounted（水合完成后）才发出，模拟链路是
+      // 「水合 → 发请求 → 等服务端 → 回填渲染」，IPv6 行作为 LCP 元素被整段串行拖住
+      // （mobile 模拟 LCP 2275ms，满分线约 1600ms）。
+      // 这里在 head 里用内联脚本立刻发起，与 render-blocking CSS 的下载、
+      // hydration 三路并行；结果挂 window.__ipProbe，完成时派发 ip-probe 事件，
+      // onMounted 只负责消费（见下方），不再等水合才起步。
+      // 用原生 fetch：此刻 ofetch 还没加载；不带 retry 的语义与旧版 retry:false 一致
+      // （底层 fetch 本来就不会重试）。
+      innerHTML: [
+        'window.__ipProbe = {};',
+        '(function () {',
+        `  function emit(key) {`,
+        `    return function (text) {`,
+        `      window.__ipProbe[key] = text;`,
+        `      document.dispatchEvent(new CustomEvent('ip-probe', { detail: key }));`,
+        `    };`,
+        `  }`,
+        // 与 onMounted 的语义一致：三接口各自独立、失败静默（保持「查询中」占位）
+        `  fetch(${JSON.stringify(config.v6OnlyAPI)}).then(function (r) { return r.text(); }).then(emit('v6')).catch(function () {});`,
+        `  fetch(${JSON.stringify(config.v4OnlyAPI)}).then(function (r) { return r.text(); }).then(emit('v4')).catch(function () {});`,
+        `  fetch(${JSON.stringify(config.DualStackAPI)}).then(function (r) { return r.text(); }).then(emit('dual')).catch(function () {});`,
+        '})();',
+      ].join('\n'),
+    },
    {
      type: 'application/ld+json',
      innerHTML: JSON.stringify({
@@ -74,56 +100,91 @@ curl ${config.v6OnlyAPI}
 # (访问 IPv4/IPv6 双栈站点，如果返回 IPv6 地址，则 IPv6 访问优先)
 curl ${config.DualStackAPI}
 `.trim(); // 关键：去掉首尾多余的空行
-const highlightedCode = ref('');
+
+// 代码高亮放在 SSR 期算：HTML 下发时就已经是带 <span> 的高亮结果，
+// 于是 ①客户端不必再下载/执行 shiki（引擎 + 语言 + 主题 ≈ 164KB）；
+// ②不会再有"先出纯文本兜底、若干秒后才换成高亮"的那次块高变化（可见重排）。
+//
+// 这段代码是构建期常量（只依赖 config，不随请求变化），所以结果可以安全地随 HTML 一起缓存。
+//
+// import 仍然写在 handler 内部（而不是文件顶层）：动态 import 会把它切成独立 chunk，
+// 只在真正要高亮时加载，不会像顶层静态 import 那样被塞进首屏的 modulepreload 列表。
+// 首次进入是 SSR 执行的；客户端水合直接读 payload（Nuxt 会序列化 useAsyncData 的结果），
+// 只有客户端软导航到本页时才在浏览器里跑一次。
+const { data: highlightedCode } = await useAsyncData(
+  'home-curl-code',
+  async () => {
+    const { highlightCode } = await import('../../utils/shiki');
+    return await highlightCode(code, 'bash');
+  },
+  // 默认值必须留空：模板是 v-if="highlightedCode" / v-else 的双分支，
+  // 给成 code 会让 v-if 命中、把纯文本当 HTML 塞进 v-html（fallback 分支永远走不到）。
+  // 留空则失败时自然落到 v-else 的 code-block--fallback，与改动前 catch 里清空的行为一致。
+  { default: () => '' },
+);

 const ipAddress = ref('');
 const yourIPv4 = ref('');
 const yourIPv6 = ref('');

 onMounted(() => {
-  // 代码高亮与三个 IP 查询互不依赖，一起发出即可。
-  // 注意别写成"先 await 高亮再发请求"：shiki 首次要把语言包拉下来，会把三次查询整体推后数百毫秒。
-  //
-  // 用动态 import 而非顶层静态 import：shiki 的引擎核心 + 语言/主题注册表约 160KB，
-  // 首页只为这 4 行 curl 示例需要它。静态 import 会把它拽进首屏同步加载的关键路径
-  // （构建后体现为一个 164KB 的 chunk 出现在 modulepreload 列表）；动态 import 后
-  // 它单独成 chunk，首屏渲染不再等它。
-  void import('../../utils/shiki')
-    .then(({ highlightCode }) => highlightCode(code, 'bash'))
-    .then((html) => {
-      highlightedCode.value = html;
-    })
-    .catch(() => {
-      highlightedCode.value = '';
-    });
+  // （代码高亮已移到 setup 顶部的 useAsyncData，随 SSR 一起产出。）

-  // 三个地址各自独立请求、各自渲染：谁先回来谁先上屏。
-  // 不用 Promise.allSettled 包起来等齐——那样只要有一个慢（例如纯 IPv4 网络下 v6 接口要等超时），
-  // 已经拿到的 IPv4 与双栈结果也得一起干等。
+  // —— 三个 IP 探测：请求已由 head 内联脚本提前发出（见 useHead），这里只消费 ——
+  // 内联脚本把结果挂 window.__ipProbe[key] 并派发 ip-probe 事件。三种时序都要覆盖：
+  //   ① 值已就位（事件在 onMounted 之前派发过）→ 同步读 store 直接上屏；
+  //   ② 值未到 → 挂监听等事件（收到匹配 key 才移除，不能 once——
+  //      三个 key 共用同一事件名，once 会把别人的事件当自己的吃掉）；
+  //   ③ window.__ipProbe 不存在（内联脚本被 CSP 拦掉/异常）→ 退回自己发请求，行为同旧版。
  //
  // retry: false —— ofetch 默认会对 GET 重发一次：网络层失败时它拿不到 response，就按 500 计
  // （500 在默认重试白名单里），且默认延迟为 0，立即重发。于是"这个节点连不上"会被原样重做一遍，
  // 用户白等一倍时间（实测 ofetch 1.5.1：裸调用触发 2 次真实 fetch，传 retry:false 后只剩 1 次；
-  // 浏览器自身不会重试，底层 fetch 对同一请求只被调用过一次）。
+  // 浏览器自身不会重试，底层 fetch 对同一请求只被调用过一次）。仅 ③ 的兜底路径会走到 $fetch。
  const ipFetchOptions = { retry: false } as const;
+  const probeStore = (window as any).__ipProbe as Record<string, string> | undefined;

-  $fetch<string>(config.DualStackAPI, ipFetchOptions)
-    .then((ip) => {
-      ipAddress.value = ip;
-    })
-    .catch(() => {
-      // 单个接口失败不影响其它两行展示，保持"查询中"占位
-    });
-  $fetch<string>(config.v4OnlyAPI, ipFetchOptions)
-    .then((ip) => {
-      yourIPv4.value = ip;
-    })
-    .catch(() => {});
-  $fetch<string>(config.v6OnlyAPI, ipFetchOptions)
-    .then((ip) => {
-      yourIPv6.value = ip;
-    })
-    .catch(() => {});
+  const consumeProbe = (key: string, apply: (ip: string) => void): boolean => {
+    if (!probeStore) return false; // ③ 内联脚本没跑起来
+    if (typeof probeStore[key] === 'string') {
+      apply(probeStore[key]); // ① 值已就位
+      return true;
+    }
+    const onProbe = (e: Event) => {
+      if ((e as CustomEvent).detail !== key) return;
+      document.removeEventListener('ip-probe', onProbe);
+      apply(probeStore[key]); // ② 事件到达
+    };
+    document.addEventListener('ip-probe', onProbe);
+    return true;
+  };
+
+  // 三个地址各自独立请求、各自渲染：谁先回来谁先上屏。
+  // 不用 Promise.allSettled 包起来等齐——那样只要有一个慢（例如纯 IPv4 网络下 v6 接口要等超时），
+  // 已经拿到的 IPv4 与双栈结果也得一起干等。
+  if (!consumeProbe('dual', (ip) => { ipAddress.value = ip; })) {
+    $fetch<string>(config.DualStackAPI, ipFetchOptions)
+      .then((ip) => {
+        ipAddress.value = ip;
+      })
+      .catch(() => {
+        // 单个接口失败不影响其它两行展示，保持"查询中"占位
+      });
+  }
+  if (!consumeProbe('v4', (ip) => { yourIPv4.value = ip; })) {
+    $fetch<string>(config.v4OnlyAPI, ipFetchOptions)
+      .then((ip) => {
+        yourIPv4.value = ip;
+      })
+      .catch(() => {});
+  }
+  if (!consumeProbe('v6', (ip) => { yourIPv6.value = ip; })) {
+    $fetch<string>(config.v6OnlyAPI, ipFetchOptions)
+      .then((ip) => {
+        yourIPv6.value = ip;
+      })
+      .catch(() => {});
+  }
 });
 </script>

@@ -136,10 +197,10 @@ onMounted(() => {
    </header>
  </div>
  <div class="content">
-    <div class="one-line">
+    <div class="one-line ip-row">
      <b>IPv4</b>&nbsp<p>{{ yourIPv4 }} </p>&nbsp<RouterLink :to="`/location?ip=${yourIPv4}`" target="_blank">查询归属地</RouterLink>
    </div>
-    <div class="one-line">
+    <div class="one-line ip-row ip-row-v6">
      <b>IPv6</b>&nbsp<p v-if="yourIPv6">{{ yourIPv6 }}</p><RouterLink :to="`/location?ip=${yourIPv6}`" target="_blank" v-if="yourIPv6">&nbsp查询归属地</RouterLink><RouterLink v-else to="/doc/user/enable_ipv6" target="_blank">没有IPv6地址,查看如何开启IPv6</RouterLink>
    </div>
    <div class="ip-priority">
@@ -173,6 +234,20 @@ onMounted(() => {
  margin: 1em 0;
 }

+/* 两行 IP 记录预留确定高度，消除 CLS。
+   实测（CDP 逐帧采样 + CSS 变体对照，填值后量终态几何）：
+   这两个 div 的文本是 onMounted 之后才由 $fetch 填上的。IPv6 地址（39 字符）
+   在窄屏下把 .one-line 从 1 行撑到 3 行，下面 .ip-priority / 代码块 / blockquote /
+   footer 被整体顶下 50px —— Lighthouse 记的 `div.code-block` 那条 CLS 0.0359
+   （占全页 88%）就是这么来的，而满分门槛只有 0.0396，差 3% 就被扣分。
+   修法是让高度与「填完之后」一致。终态高度按视口分档（CDP 实测，不是估算）：
+     移动 412 宽 → ip2 终态 75px（3 行）；桌面 1350 宽 → 30px（1 行，.content 宽 60%）
+   所以必须分媒体查询给值：一刀切 75px 会让桌面凭空多出 45px 空白。
+   代价是接口 pending 时这里空着，但换来 CLS 归零。 */
+.ip-row {
+  min-height: 30px;
+}
+
 .code-block {
  margin-top: 1rem;
  padding: 1rem;
@@ -191,17 +266,30 @@ onMounted(() => {
 }

@media (max-width: 768px) {
-  .ip-priority h2 {
-    font-size: 1.1em;
-  }
-  .code-block {
-    padding: 0.75rem;
-    font-size: 0.8em;
-  }
+    .ip-priority h2 {
+      font-size: 1.1em;
+    }
+    .code-block {
+      padding: 0.75rem;
+      font-size: 0.8em;
+    }
+    /* 窄屏下 IPv6 地址换 3 行（CDP 实测 412 宽终态 h=75px），见上面 .ip-row 的注释。
+       75px 只给 IPv6 行：IPv4 地址窄屏仍是 1 行（~30px），一刀切 75px 会让
+       IPv4 行下部空出 ~45px，两块 IP 之间出现一大段空白。
+       IPv4 回填前后都是 1 行 30px，高度不变 → 不引入新的 CLS。 */
+    .ip-row {
+      /* style.css 窄屏给 .one-line 加了 0.5em 上下 margin（两块之间叠 16px），
+         IP 行的间距由行高本身决定，这里归零。scoped 属性选择器特异性更高，稳赢。 */
+      margin: 0;
+    }
+    .ip-row-v6 {
+      min-height: 75px;
+      align-content: flex-start;
+    }
 }
 </style>
 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 </style>
@@ -272,10 +272,10 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -287,11 +287,11 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 .el-icon {
@@ -305,10 +305,10 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -67,7 +67,22 @@ curl ${config.v6OnlyAPI}
 # (访问 IPv4/IPv6 双栈站点，如果返回 IPv6 地址，则 IPv6 访问优先)
 curl ${config.DualStackAPI}
 `.trim();
-const html = ref('');
+
+// 代码高亮放 SSR 期算（与首页同款做法）：HTML 里直接是带 <span> 的高亮结果，
+// 客户端不必再下载/执行 shiki（引擎 + 语言 + 主题 ≈ 164KB），也不会出现
+// "先渲染纯文本、稍后换成高亮"的块高变化。代码是构建期常量，结果可随 HTML 一起缓存。
+// import 写在 handler 内部（动态 import 单独成 chunk），首屏不会预载它。
+const { data: html } = await useAsyncData(
+  'location-curl-code',
+  async () => {
+    const { highlightCode } = await import('../../utils/shiki');
+    return await highlightCode(code, 'bash');
+  },
+  // 默认值给 code（不是空串）：这里模板只有单个 v-html，没有 fallback 分支，
+  // 高亮失败时正好退回原始代码文本，别让代码块空着。
+  // （首页那处模板有 v-else 分支，所以那边默认值必须留空，两处不可照抄。）
+  { default: () => code },
+);
 const apiList = config.IPLocationAPI
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
@@ -117,18 +132,7 @@ function locateIP(IP: string){
 }

 onMounted(async () => {
-  // 代码高亮与下面的「取本机 IP / 定位查询」互不依赖，别把它摆在流程最前面 await ——
-  // 否则后面那次 $fetch 要等 160KB 的 shiki 下载完才会发出。
-  // 动态 import 让 shiki（引擎 + 语言/主题注册表）单独成 chunk，首屏渲染不再等它。
-  void import('../../utils/shiki')
-    .then(({ highlightCode }) => highlightCode(code, 'bash'))
-    .then((h) => {
-      html.value = h
-    })
-    .catch(() => {
-      // 连 import 本身都失败时退回原始代码，别让代码块空着
-      html.value = code
-    })
+  // （代码高亮已移到 setup 顶部的 useAsyncData，随 SSR 一起产出，这里只剩定位查询。）

  const urlParam = route.query.ip;
  if (urlParam) {
@@ -257,7 +261,7 @@ onMounted(async () => {
 <style>
@import "../style.css";
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -440,7 +444,7 @@ html.dark pre code {

 .badge-item h4 {
  margin: 0 0 15px 0;
-  color: #3EAF7C;
+  color: #299764;
  font-size: 1.2em;
 }

@@ -286,7 +286,7 @@ html.dark .loading-overlay p {
 }

 .markdown :deep(a) {
-  color: #3EAF7C !important;
+  color: #299764 !important;
  font-size: 1.3em;
  text-decoration: none
 }
@@ -272,10 +272,10 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -389,7 +389,7 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -271,11 +271,11 @@ onMounted(() => {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }

 .el-icon {
@@ -281,7 +281,7 @@ function getStatusClass(status: string): string {
@import "../style.css";
@import "../../assets/css/tool-common.css";
 .markdown :deep(a) {
-  color: #3EAF7C !important;
+  color: #299764 !important;
  font-size: 1.3em;
  text-decoration: none
 }
@@ -319,10 +319,10 @@ function getStatusClass(status: string): string {

 <style>
 :root {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 html.dark {
-  --el-color-primary: #3EAF7C;
+  --el-color-primary: #299764;
 }
 .el-icon{
  font-size: 1.3em;
@@ -31,7 +31,10 @@ h3{
 }
 .title p{
    font-size: 25.6px;
-    color: #6A8BAD;
+    /* 首页副标题。原来 #6A8BAD 在白底只有 3.55:1（axe color-contrast，
+       是移动端 12 条里唯一不是链接/代码的那条）；加深到 #4D7396 = 4.99:1，
+       色相不变、只是明度降一档。 */
+    color: #4D7396;
    margin-right: 20px;
    margin-left: 20px;
    text-align: center;
@@ -106,14 +109,14 @@ blockquote p {
    margin: 0.5em;
 }
 blockquote a{
-    color: #3EAF7C;
+    color: var(--link-color);
    font-size: 1em;
-    /* 正文里的链接仅靠颜色区分不够（绿 #3EAF7C 与周围正文的对比度远低于 3:1），
+    /* 正文里的链接仅靠颜色区分不够（绿 #299764 与周围正文的对比度远低于 3:1），
       补下划线提供「非颜色」的视觉区分（link-in-text-block） */
    text-decoration: underline
 }
 a {
-    color: #3EAF7C;
+    color: var(--link-color);
    font-size: 1.3em;
    text-decoration: none
    
@@ -129,7 +132,7 @@ footer .one-line {
 footer .one-line a {
    font-size: 1em;
    text-align: center;
-    color: #3EAF7C;
+    color: var(--link-color);
    text-decoration: none
 }
 footer {
@@ -204,7 +207,7 @@ footer {
    }
    blockquote a{
      
-        color: #3EAF7C;
+        color: var(--link-color);
        font-size: 1em;
        /* 与上面的非窄屏规则保持一致：窄屏同样靠下划线做非颜色区分。
           此处若仍写 none，因其位置在后、特异性相同，会把桌面的 underline 盖掉。 */
@@ -269,7 +272,7 @@ h4>.header-anchor,
 h5>.header-anchor,
 h6>.header-anchor {
    opacity: 1;
-    color: #3EAF7C;
+    color: var(--link-color);
 }

 h1:hover>.header-anchor,
@@ -282,5 +285,5 @@ h6:hover>.header-anchor {
 }
 .header-anchor::before {
    content: "#";
-    color: #3EAF7C;
+    color: var(--link-color);
 }
@@ -226,7 +226,7 @@ html.dark pre code {

 .badge-item h4 {
  margin: 0 0 15px 0;
-  color: #3EAF7C;
+  color: #299764;
  font-size: 1.2em;
 }

@@ -124,6 +124,10 @@ const config = {
                id: "cn-shenzhen",
                url: "https://cn-shenzhen.api-ipw.wsmdn.top/"
            },
+            {
+                label: "河南 安阳 联通",
+                "id": "anyang-cu"
+            }
            // {
            //     label: "中国 湖北 武汉 电信",
            //     id: "cn-wuhan-chinatelecom",
@@ -1,5 +1,4 @@
 import {config} from "./config/index";
-import { docConfig } from "./config/doc";
 // https://nuxt.com/docs/api/configuration/nuxt-config
 const extractDomains = (obj: any): string[] => {
  // 将对象转为 JSON 字符串，用正则匹配所有 https:// 开头的域名部分
@@ -10,9 +9,42 @@ const extractDomains = (obj: any): string[] => {
 };

 const allowedDomains = extractDomains(config);
+
+// 首屏「IPv4 / IPv6 / 优先级」三行的数据源（见 app/pages/index.vue 的 onMounted）：
+// 三个接口分属三个独立源站，且都要等水合完成后才发起 —— 那时才做 DNS+TCP+TLS 太晚。
+// 把它们抽出来做 preconnect，让握手在 HTML 解析期就开始。
+const ipProbeOrigins = [
+  config.DualStackAPI,
+  config.v4OnlyAPI,
+  config.v6OnlyAPI,
+].map((url) => new URL(url).origin);
+// 中间件（工具页 /middleware/* 的上游）：只在部分页面用到，DNS 预解析即可，不占连接。
+const middlewareOrigin = config.Middleware?.[0]
+  ? new URL(config.Middleware[0]).origin
+  : null;
+
 export default defineNuxtConfig({
  compatibilityDate: '2025-07-15',
  devtools: { enabled: true },
+  experimental: {
+    // 关闭 app manifest 版本检查：水合后 Nuxt 会在 requestIdleCallback 里请求
+    // /_nuxt/builds/meta/<buildId>.json，buildId 对不上（本地「服务旧、磁盘新」、
+    // 或线上发版切换瞬间）就抛 NUXT_E5002 污染 console，还拖累 Best Practices 分。
+    // 本项目没依赖 appManifest 的客户端能力（无客户端 routeRules、无 prerender
+    // 判定），关掉少一个请求，console 永远干净。
+    appManifest: false,
+    // 注：inlineStyles: true 实测是负优化——它只内联 page 组件样式（+12KB HTML），
+    // entry/EP 等共享样式仍是 render-blocking 外链，关键请求一个没省。勿开。
+    defaults: {
+      nuxtLink: {
+        // NuxtLink 默认「链接进入视口就预取目标页 JS」——顶栏 15 个菜单项会让
+        // 首屏把其它工具页的 chunk（含 87KB 的校验库等重依赖）全拉下来，
+        // 白吃带宽还挤占首屏关键请求。改为「悬停/聚焦才预取」：真正要去
+        // 哪个页面时再拉那一页，首屏只加载当前页需要的代码。
+        prefetchOn: { interaction: true, visibility: false },
+      },
+    },
+  },
  modules: [
    "nitro-cloudflare-dev",
    '@element-plus/nuxt',
@@ -31,6 +63,24 @@ export default defineNuxtConfig({
      ]
    },
  },
+  hooks: {
+    // 掐掉「当前路由的动态 import 预取」。
+    // Nuxt 的 vue-bundle-renderer 会把 manifest 里带 prefetch 标记的动态 chunk
+    // 渲染成 `<link rel="prefetch" as="script">`，于是首页一边解析 HTML 一边就把
+    // shiki 高亮器那一整块（实测 165 KB，占首页字节 25%）下下来了 —— 而高亮已经在
+    // SSR 期算完写进 HTML，客户端根本不会执行它，纯属白下。
+    // 把 manifest 上的标记抹掉即可：动态 chunk 回到「真正 import 时才加载」。
+    // 静态闭包走的是 preload 分支（modulepreload），不受影响。
+    // —— 2026-10-04 曾试把 preload 也置 false：FCP 确实 2333→1404（少了 22 个请求的
+    // 下载竞争），但 LCP 2387→2933、TBT 86→280（权重 25%/30% 远大于 FCP 的 10%），
+    // 总分 94→89 净亏。原因：这 22 个 modulepreload 是 entry 的静态依赖闭包，全掐掉后
+    // hydration 推迟、长任务落进 LCP/TBT 窗口。故只掐 prefetch，preload 必须留。
+    'build:manifest': (manifest) => {
+      for (const chunk of Object.values(manifest) as unknown as Array<Record<string, unknown>>) {
+        if (chunk.prefetch) chunk.prefetch = false
+      }
+    },
+  },
  site: { 
  url: config.siteUrl, 
  name: 'Lemon IPW' 
@@ -66,7 +116,17 @@ export default defineNuxtConfig({
        }
      ],
      link: [
-        { rel: 'icon', type: 'image/x-icon', href: '/favicon.svg' }
+        { rel: 'icon', type: 'image/x-icon', href: '/favicon.svg' },
+        // preconnect 三个 IP 探测源站。crossorigin 不能省：$fetch 走 fetch() 的跨域
+        // （CORS）模式，不带它预热出来的是 no-cors 连接，真正的 fetch 用不上、还得重连。
+        ...ipProbeOrigins.map((href) => ({
+          rel: 'preconnect',
+          href,
+          crossorigin: 'anonymous',
+        } as const)),
+        ...(middlewareOrigin
+          ? [{ rel: 'dns-prefetch', href: middlewareOrigin } as const]
+          : []),
      ]
    }
  },
@@ -75,15 +135,22 @@ export default defineNuxtConfig({
    apiKeys: '',
    public: {
      siteUrl: config.siteUrl,
-      docConfig: docConfig,
-
+      // 这里**不要**再放 docConfig：runtimeConfig.public 会被整份序列化进
+      // 每个页面 HTML 的 `window.__NUXT__.config`，而这份文档树（32 条 title+description）
+      // 实测占 4571 字节 —— 也就是每一页的 HTML 都白白多背 4.5KB（首页 HTML 的 10%）。
+      // 它全站只有一个消费方，且是服务端路由（server/api/__sitemap__/urls.ts），
+      // 那里改成直接 import 构建期常量即可；文档页本来就用 `getDocMeta` 直接 import。
    },
  },
  routeRules: {
-    // /doc 文档站改为 SSG：构建时预渲染为静态 HTML，由边缘静态资源直接响应
-    '/doc/**': { prerender: true },
+    // 缓存头一律不在这里设，交由 CDN（EdgeOne）侧控制。
+    // /doc/** 曾经是 SSG（prerender），已撤回改为 SSR，原因见下方 nitro.prerender 处的注释。
  },
  nitro: {
+    // 构建期给 public/ 静态资源生成 .gz/.br 预压缩副本，按 Accept-Encoding 直接回；
+    // SSR HTML 的压缩在 server/plugins/compress-html.ts。两者合起来让本地直连的
+    // 传输体积与线上（EdgeOne 会压）一致，Lighthouse 的 Lantern 模拟才不会虚高。
+    compressPublicAssets: true,
    publicAssets: [
      {
        dir: 'public',
@@ -95,17 +162,21 @@ export default defineNuxtConfig({
        target: 'es2022' // 明确告诉 Nitro 使用 es2022 进行打包
      }
    },
-    prerender: {
-      // 显式列出所有 doc 路由（来自 config/doc.ts 的 docConfig 键），
-      // 让动态 [...slug] 页面在构建时全部预渲染为静态 HTML
-      routes: ['/doc', ...Object.keys(docConfig).filter((p) => p !== '/doc')],
-    },
+    // 这里曾用 prerender.routes 把整份 docConfig 的文档页在构建期预渲染成静态 HTML。
+    // 已撤回，改回 SSR —— 因为预渲染与「按请求头决定渲染形态」根本冲突：
+    // 构建期没有请求头，窄屏判定恒为宽屏，于是预渲染产物里永远躺着
+    // 「15 条桌面顶栏菜单 + 被 CSS 隐藏的 40 项文档侧栏」；真手机打开时客户端判定为窄屏，
+    // 首帧 vdom 与 HTML 对不上，Vue 水合直接抛
+    // `Cannot read properties of null (reading 'nodeType')`，整页变成 500。
+    // 顺带收益：/doc 现在也走运行时安全头（预渲染页拿不到 CSP，见下方 security.ssg）。
+    // 代价只是源站多跑一层 SSR，前面有 EdgeOne 缓存兜着。
  },
  security: {
    ssg: {
-      // /doc 预渲染页的 CSP 会因 SRI modulepreload 哈希全量拼入而单行超 2000 字符，
-      // 触发 Cloudflare _headers 限制；关闭静态页安全头写入 _headers。
-      // SSR 页面仍由运行时中间件下发完整安全头，不受影响。
+      // 预渲染页的 CSP 会因 SRI modulepreload 哈希全量拼入而单行超 2000 字符，
+      // 触发 Cloudflare _headers 限制，故关掉静态页的安全头写入。
+      // 当前没有预渲染路由（/doc/** 已改回 SSR），这条是留给将来再开 prerender 时的开关：
+      // 一旦重新启用 prerender，那些页就会退回「无 CSP」状态。
      nitroHeaders: false,
    },
    headers: {
@@ -1,11 +1,12 @@
 import { defineSitemapEventHandler } from '#imports'
+// 直接 import 构建期常量，而不是走 runtimeConfig.public.docConfig：
+// 后者会被 Nuxt 序列化进每个页面的 HTML（4571 字节 / 页），而本路由是全站唯一消费方。
+// 相对路径与 server/routes/middleware/[...slug].get.ts 保持一致（`~` 在 Nuxt 4 里指向 app/，指不到根目录的 config/）。
+import { docConfig } from '../../../config/doc'


 export default defineSitemapEventHandler(async () => {
-    const config = useRuntimeConfig();
-    console.log('Generating sitemap URLs from docConfig:', config.public.docConfig);
-
-    const urls = config.public.docConfig ? Object.keys(config.public.docConfig).map(path => ({ path })) : [];
+    const urls = Object.keys(docConfig).map(path => ({ path }));

    return urls.map(url => ({
        loc: url.path,
@@ -0,0 +1,76 @@
+import { brotliCompressSync, gzipSync, constants } from 'node:zlib'
+import type { NitroApp } from 'nitro/types'
+
+/**
+ * SSR HTML 压缩。
+ *
+ * ## 为什么要压
+ *
+ * nitro 不压 SSR 响应体（静态资源另有 compressPublicAssets 预压缩），
+ * 本地直连 / Lighthouse 测到的 HTML 就是裸传的。生产链路前面有 EdgeOne 兜底，
+ * 但源站自己压是标准做法，也让本地测量贴近线上。
+ *
+ * 只压 SSR 渲染出的 text/html：body 是字符串、体积 > 1KB、对方 Accept-Encoding
+ * 支持才压，按客户端优先级选 br（brotli）否则 gzip。
+ *
+ * ## 为什么必须显式指定 brotli quality = 4（别删这行）
+ *
+ * `brotliCompressSync` 不带 params 时默认 **quality 11**，那是给「离线压一次、
+ * 反复复用」准备的（压一次存盘，读一万次）。SSR 是**每请求现压**：
+ *
+ *   quality    33KB HTML      68KB HTML
+ *   11         123ms / 7.2KB  169ms / 11.0KB
+ *   6            4ms / 7.8KB    5ms / 12.2KB
+ *   4            2ms / 8.6KB    3ms / 13.5KB
+ *
+ * Node 是单线程，这段同步压缩**全程阻塞事件循环，直接进 TTFB**。
+ * 首页 TTFB 实测：q11 时 225~260ms，改 q4 后 55~105ms —— 差的就是这 120~170ms。
+ * q4 只多 2.5KB，在 1.6Mbps 上是 12ms，换回 166ms，净赚。
+ *
+ * 教训：凡「每请求现压」的同步压缩都要显式指定质量，别吃库默认值。
+ */
+export default defineNitroPlugin((nitroApp: NitroApp) => {
+  nitroApp.hooks.hook('render:response', (response, { event }) => {
+    const headers = (response.headers ??= {})
+    const type = String(
+      headers['content-type'] ?? event.node.res.getHeader('content-type') ?? '',
+    )
+    if (!type.includes('text/html')) return
+    if (typeof response.body !== 'string' || response.body.length < 1024) return
+    if (headers['content-encoding']) return // 已有编码（异常路径），不叠加
+
+    // —— modulepreload 降优先级（2026-10-04 实测，mobile LH 三档对比后选定 low）——
+    // entry 的 26 个静态依赖 chunk 默认 High 优先级，和 4 个 render-blocking CSS 一起
+    // 排队（本地 H1 只有 6 个连接），CSS 被挤到后面 ⇒ Lantern 模拟 FCP 2345ms。
+    // 加 fetchpriority="low" 后 CSS 先行：FCP 2345→1109（-1236ms，首次过 1800 满分线），
+    // desktop 三轮全 100。代价是 JS 下载推迟 → hydration 落到 FCP 之后，TBT 86→213。
+    // 三档实测（mobile perf）：无 fp 94/95，medium 92/93（medium 仍挤 CSS，FCP 2253，
+    // 收益尽失），low 94/95 —— low 总分最优。
+    // TBT 的 213 是这项改动的全部代价：FCP 提前后，原本在 FCP 前不计账的 hydration
+    // 长任务进了 TBT 窗口（FCP 每提前 ~500ms，TBT 约 +55，两者在当前架构下互斥）。
+    if (response.body.includes('rel="modulepreload"')) {
+      response.body = response.body.replaceAll(
+        'rel="modulepreload"',
+        'rel="modulepreload" fetchpriority="low"',
+      )
+    }
+
+    const accept = String(event.node.req.headers['accept-encoding'] ?? '')
+    let encoding: 'br' | 'gzip'
+    if (/\bbr\b/.test(accept)) {
+      response.body = brotliCompressSync(Buffer.from(response.body), {
+        params: { [constants.BROTLI_PARAM_QUALITY]: 4 },
+      })
+      encoding = 'br'
+    } else if (/\bgzip\b/.test(accept)) {
+      response.body = gzipSync(Buffer.from(response.body))
+      encoding = 'gzip'
+    } else {
+      return
+    }
+
+    headers['content-encoding'] = encoding
+    // 体积变了，content-length 必须跟着改，否则连接会被截断/挂起
+    headers['content-length'] = String((response.body as Buffer).length)
+  })
+})
@@ -2,7 +2,14 @@ import { codeToHtml } from './shiki.bundle'

 export async function highlightCode(code: string, lang: string) {
  try {
-    return await codeToHtml(code, { lang, theme: 'github-dark' })
+    return await codeToHtml(code, {
+      lang,
+      theme: 'github-dark',
+      // github-dark 的注释色 #6A737D 在它自带底色 #24292E 上只有 3.04:1（axe 的 color-contrast，
+      // 首页 12 条里有 5 条都是它）。用 shiki 原生的颜色替换提亮到 #8B949E = 4.77:1 ——
+      // 只动这一个 token，换主题（比如已在 bundle 里的 vitesse-dark）会把整块代码的配色一起换掉。
+      colorReplacements: { '#6a737d': '#8b949e' },
+    })
  } catch (error) {
    console.error('Error highlighting code:', error)
    return code
@@ -4,7 +4,9 @@
 #   - 自动检测架构并下载最新 release 二进制
 #   - 交互式输入配置（环境变量注入，无需 setting.json）
 #   - 生成并启用 systemd 守护进程
-# 用法：sudo bash install.sh
+#   - 非 root 运行时会提示是否改用 systemd --user（用户级服务）
+# 用法：sudo bash install.sh      # 系统级安装（推荐，开机自启、独立于登录会话）
+#       bash install.sh          # 非 root：确认后走 systemd --user，仅对当前用户生效
 # ============================================================

 text="
@@ -20,15 +22,58 @@ echo "$text"

 set -e

-# ---------- 前置检查 ----------
+# ---------- 前置检查与 systemd 作用域 ----------
+
+# system = 系统级：写 /etc/systemd/system，开机自启走 multi-user.target（需 root）
+# user   = 用户级：写 ~/.config/systemd/user，开机自启走 default.target（systemd --user，无需 root）
+SYSTEMD_MODE="system"
+
 if [ "$(id -u)" -ne 0 ]; then
-    echo "错误：需要 root 权限（写入 /etc/systemd/system 与安装目录），请用 sudo 运行" >&2
-    exit 1
+    echo "提示：当前不是 root 环境，无法写入 /etc/systemd/system 与系统安装目录。"
+    read -r -p "是否改用 systemd --user（用户级服务，仅对当前用户生效）？[y/N]: " USE_USER_SYSTEMD
+    case "${USE_USER_SYSTEMD,,}" in
+        y|yes) SYSTEMD_MODE="user" ;;
+        *)
+            echo "已取消：如需系统级安装，请用 sudo 重新运行" >&2
+            exit 1
+            ;;
+    esac
 fi
+
 if ! command -v systemctl >/dev/null 2>&1; then
    echo "错误：未检测到 systemd（systemctl 不存在），无法创建守护进程" >&2
    exit 1
 fi
+# 用户级实例依赖登录会话与 DBus，容器 / cron 等环境常常拿不到，提前拦掉
+if [ "$SYSTEMD_MODE" = "user" ] && ! systemctl --user list-units >/dev/null 2>&1; then
+    echo "错误：当前环境无法使用 systemd --user（无用户级 systemd 实例或缺少 DBus 会话）" >&2
+    echo "      可改用 sudo bash install.sh 做系统级安装" >&2
+    exit 1
+fi
+
+SERVICE_NAME="lemon-ipw"
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    SERVICE_FILE="${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user/${SERVICE_NAME}.service"
+    DEFAULT_INSTALL_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/lemon-ipw"
+    UNIT_USER_LINE=""
+    UNIT_NETWORK_LINES=""
+    UNIT_WANTED_BY="default.target"
+else
+    SERVICE_FILE="/etc/systemd/system/${SERVICE_NAME}.service"
+    DEFAULT_INSTALL_DIR="/opt/lemon-ipw"
+    # 系统级 unit 的 User= 行与 network-online 依赖；用户级没有这两个概念
+    UNIT_USER_LINE="User=root
+"
+    UNIT_NETWORK_LINES="After=network-online.target
+Wants=network-online.target
+"
+    UNIT_WANTED_BY="multi-user.target"
+fi
+
+# 统一 systemctl / journalctl 调用（用户级自动补 --user）
+sc() { if [ "$SYSTEMD_MODE" = "user" ]; then systemctl --user "$@"; else systemctl "$@"; fi; }
+jc() { if [ "$SYSTEMD_MODE" = "user" ]; then journalctl --user "$@"; else journalctl "$@"; fi; }
+
 if ! command -v wget >/dev/null 2>&1 && ! command -v curl >/dev/null 2>&1; then
    echo "错误：未找到 wget 或 curl，无法下载" >&2
    exit 1
@@ -68,8 +113,16 @@ echo "========================================"
 echo " 配置后端节点（直接回车使用默认值）"
 echo "========================================"

-read -r -p "安装目录 [/opt/lemon-ipw]: " INSTALL_DIR
-INSTALL_DIR=${INSTALL_DIR:-/opt/lemon-ipw}
+read -r -p "安装目录 [$DEFAULT_INSTALL_DIR]: " INSTALL_DIR
+INSTALL_DIR=${INSTALL_DIR:-$DEFAULT_INSTALL_DIR}
+# unit 里 WorkingDirectory/ExecStart 按 systemd 语法裸写（不加引号），
+# 路径含空白会被拆成多个参数导致启动失败，这里提前拦掉
+case "$INSTALL_DIR" in
+    *[[:space:]]*)
+        echo "错误：安装目录不能包含空格或制表符（当前值：$INSTALL_DIR）" >&2
+        exit 1
+        ;;
+esac

 read -r -p "监听端口 [8080]: " PORTS
 PORTS=${PORTS:-8080}
@@ -82,10 +135,10 @@ read -r -p "DNS 服务器（留空=启动时自动探测系统 DNS；主从逗

 read -r -p "DNSSEC 专用 DNS（留空=沿用上面 dns-server）: " DNSSEC_DNS_SERVER

-read -r -p "启用 IP 数据库 ipdb（首次启动下载约 450MB）[Y/n]: " IPDB_CHOICE
+read -r -p "启用 IP 数据库 ipdb（首次启动下载约 450MB，用于 IP 归属地/ASN 类拨测）[y/N]: " IPDB_CHOICE
 case "${IPDB_CHOICE,,}" in
-    n|no) IPDB="false" ;;
-    *)    IPDB="true" ;;
+    y|yes) IPDB="true" ;;
+    *)     IPDB="false" ;;
 esac

 read -r -p "CORS 允许来源（逗号分隔，留空=不限）: " CORS
@@ -106,11 +159,35 @@ NODE_KEY=""
 WS_USED_DEFAULT=""
 case "${WS_CHOICE,,}" in
    y|yes)
-        read -r -p "  中间件 WS 完整地址（含 wss:// 前缀与 /ws 路径，如 wss://host:8092/ws；留空=贡献节点给柠檬 wss://boce-api.api-ipw.wsmdn.top/ws；逗号分隔多个将同时连接全部）: " WS_URL
+        read -r -p "  中间件 WS 完整地址（含 wss:// 前缀与 /ws 路径，如 wss://host:8092/ws；多个用逗号分隔将同时连接全部；留空=贡献节点给柠檬的两条公共中间件）: " WS_URL
        if [ -z "$WS_URL" ]; then
-            WS_URL="wss://boce-api.api-ipw.wsmdn.top/ws"
+            WS_URL="wss://boce-api.api-ipw.wsmdn.top/ws,wss://middleware-1.api-ipw.wsmdn.top/ws"
            WS_USED_DEFAULT="true"
        fi
+        # 多地址（逗号分隔）：逐段去掉首尾空白并校验 scheme。
+        # 不清理的话空格会原样写进 unit 的 Environment，节点侧解析失败后只会反复重连，很难排查。
+        _ws_norm=""
+        _old_ifs="$IFS"; IFS=','
+        for _seg in $WS_URL; do
+            _seg="${_seg#"${_seg%%[![:space:]]*}"}"
+            _seg="${_seg%"${_seg##*[![:space:]]}"}"
+            case "$_seg" in
+                ws://*|wss://*) ;;
+                "")
+                    IFS="$_old_ifs"
+                    echo "错误：WS 地址含空段（检查是否多写了逗号）" >&2
+                    exit 1
+                    ;;
+                *)
+                    IFS="$_old_ifs"
+                    echo "错误：WS 地址的每一段都需以 ws:// 或 wss:// 开头（问题段：${_seg}）" >&2
+                    exit 1
+                    ;;
+            esac
+            _ws_norm="${_ws_norm:+${_ws_norm},}${_seg}"
+        done
+        IFS="$_old_ifs"
+        WS_URL="$_ws_norm"
        read -r -p "  注册 key（留空自动生成，中间件 ws-keys 必须包含此节点，否则注册被拒 401）: " NODE_KEY
        if [ -z "$NODE_KEY" ]; then
            NODE_KEY=$(gen_uuid | tr -d '-')
@@ -141,6 +218,11 @@ echo " 配置汇总"
 echo "========================================"
 echo "安装目录:     $INSTALL_DIR"
 echo "服务名:       lemon-ipw"
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    echo "服务作用域:   用户级（systemd --user，仅对当前用户生效）"
+else
+    echo "服务作用域:   系统级（systemd）"
+fi
 echo "监听端口:     $PORTS"
 echo "节点 id:      $NODE_ID"
 echo "单栈模式:     ${SINGLE_STACK:-双栈}"
@@ -182,7 +264,9 @@ chmod +x "$INSTALL_DIR/lemonipw"
 echo "二进制已安装到 $INSTALL_DIR/lemonipw"

 # ---------- 生成 systemd 服务 ----------
-SERVICE_FILE="/etc/systemd/system/lemon-ipw.service"
+
+# 用户级 unit 目录（~/.config/systemd/user）默认可能不存在
+mkdir -p "$(dirname "$SERVICE_FILE")"

 # 收集环境变量（仅非空的写入，避免空值覆盖默认）
 # 值里的双引号/反斜杠需要转义，否则会提前终止 systemd 的引号包裹、损坏 unit
@@ -216,43 +300,66 @@ fi
 cat > "$SERVICE_FILE" << EOF
 [Unit]
 Description=Lemon IPW Backend Node
-After=network-online.target
-Wants=network-online.target
-
+${UNIT_NETWORK_LINES}
 [Service]
 Type=simple
-User=root
-WorkingDirectory="${INSTALL_DIR}"
-ExecStart="${INSTALL_DIR}/lemonipw"
+${UNIT_USER_LINE}WorkingDirectory=${INSTALL_DIR}
+ExecStart=${INSTALL_DIR}/lemonipw
 ${ENV_LINES}Restart=always
 RestartSec=5

 [Install]
-WantedBy=multi-user.target
+WantedBy=${UNIT_WANTED_BY}
 EOF

 echo "已生成服务文件 $SERVICE_FILE"

 # ---------- 启动服务 ----------
-systemctl daemon-reload
+sc daemon-reload
 # restart 而非 enable --now：重跑安装改配置后旧进程必须重启才会生效
-systemctl enable lemon-ipw
-systemctl restart lemon-ipw
-systemctl status lemon-ipw --no-pager | head -15
+sc enable lemon-ipw
+sc restart lemon-ipw
+sc status lemon-ipw --no-pager | head -15
+
+# 用户级服务默认随最后一个会话结束而停止，注销后要继续跑必须开 linger
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    if loginctl show-user "$(id -un)" -p Linger 2>/dev/null | grep -q 'Linger=yes'; then
+        echo "linger 已启用：用户注销后服务继续运行"
+    elif loginctl enable-linger "$(id -un)" >/dev/null 2>&1; then
+        echo "已启用 linger：用户注销后服务继续运行"
+    else
+        echo "提示：未能自动启用 linger，注销后服务会被停止。请手动执行：" >&2
+        echo "      sudo loginctl enable-linger $(id -un)" >&2
+    fi
+fi

 echo ""
 echo "========================================"
 echo " 安装完成"
 echo "========================================"
+# 用户级服务的运维命令都要带 --user，否则看到的是系统级命名空间（空）
+if [ "$SYSTEMD_MODE" = "user" ]; then
+    CTL_CMD="systemctl --user"
+    JRN_CMD="journalctl --user -u"
+else
+    CTL_CMD="systemctl"
+    JRN_CMD="journalctl -u"
+fi
 echo "常用命令："
-echo "  systemctl status lemon-ipw      # 查看状态"
-echo "  journalctl -u lemon-ipw -f      # 查看日志"
-echo "  systemctl restart lemon-ipw     # 重启（改配置后）"
+echo "  $CTL_CMD status lemon-ipw      # 查看状态"
+echo "  $JRN_CMD lemon-ipw -f      # 查看日志"
+echo "  $CTL_CMD restart lemon-ipw     # 重启（改配置后）"
 echo "验证：curl http://127.0.0.1:$PORTS/ 应返回 {\"status\":\"ok\"}"
 if [ -n "$WS_URL" ]; then
    echo ""
-    echo "WS 通道已启用，请把节点注册信息加入中间件 setting.json 的 ws-keys："
+    echo "WS 通道已启用，请把节点注册信息加入每一个对应中间件 setting.json 的 ws-keys（缺一个该条连接会被拒 401）："
    echo "  \"$NODE_ID\": \"$NODE_KEY\""
+    echo "  地址清单："
+    _old_ifs="$IFS"; IFS=','
+    for _seg in $WS_URL; do
+        echo "    - $_seg"
+    done
+    IFS="$_old_ifs"
 fi
 if [ -n "$WS_USED_DEFAULT" ]; then
    echo ""
@@ -43,7 +43,7 @@ import (
 	"time"

 	"github.com/coder/websocket"
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v3"
 	"github.com/spf13/viper"
 	"lemon-ipw/ssrf"
 	"lemon-ipw/webtest"
@@ -101,7 +101,8 @@ func protectedKeysIn(cfg map[string]any) []string {

 // configRestartKeys 改了内存变量但需重启进程才完全生效的键：
 //
-//   - port / trusted-proxies / cors：监听地址与 gin 中间件在启动时构建并固定
+//   - port / trusted-proxies / cors：监听地址与 fiber 应用配置（buildFiberConfig，含 CORS
+//     中间件）都在启动时构建并固定
 //   - ipdb：ipdb.Init 与 location / asn 路由注册都按启动时的值判定
 //   - report-interval-seconds：上报 ticker 在启动时按该值创建
 //   - node-id / node-key：WS 注册身份在启动时确立；运行中改动只改内存变量，
@@ -112,7 +113,8 @@ func protectedKeysIn(cfg map[string]any) []string {
 // （ws.go 的 reconcileWSClient）按新地址多退少补，连接集合随配置变化，无需重启。
 //
 // 不在其中的键即为热生效：`dns-server` / `dnssec-server` / `block-private-ips` /
-// `single-stack` / `node-ota` 每次消费时重新读变量。
+// `single-stack` / `node-ota` / `access-log` 每次消费时重新读变量
+// （`access-log` 的中间件虽在启动时挂载，但开关判定在请求路径上，因此同样热生效）。
 //
 // 判定口径：只有**值真的变了**才算需重启（见 applyConfigMap）——远端/托管配置每次都带全部键，
 // 若按"键出现过"判定，每次 refresh 都会把节点误报成"需重启"。
@@ -183,12 +185,23 @@ func applyConfigMap(cfg map[string]any, ignore []string) (applied, unknown, rest
 			webtest.SetDNSSecServer(v)
 		case "ipdb":
 			// 仅改变量不够：ipdb.Init 与 location/asn 路由注册都在启动时按该值判定，运行中不重建
-			IPDB = v
+			enabled, known := parseBoolSwitch(v)
+			if !known {
+				unknown = append(unknown, key)
+				continue
+			}
+			IPDB_ENABLED = enabled
 		case "cors":
 			CORS = v
 			ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 		case "block-private-ips":
-			ssrf.SetEnabled(v != "false" && v != "0")
+			// 与启动口径共用 parseBoolSwitch（main.go），避免"启动认 false、热更新认 FALSE"这类漂移
+			enabled, known := parseBoolSwitch(v)
+			if !known {
+				unknown = append(unknown, key) // 值非法：不覆盖原值，明确报给调用方
+				continue
+			}
+			ssrf.SetEnabled(enabled)
 		case "trusted-proxies":
 			TRUSTED_PROXIES = v
 		case "remote-config-url":
@@ -229,12 +242,40 @@ func applyConfigMap(cfg map[string]any, ignore []string) (applied, unknown, rest
 			REPORT_INTERVAL = n
 		case "node-ota":
 			// 热生效：下发 OTA 指令时才读 NODE_OTA（见 ota.go），故不在 configRestartKeys
-			enabled, known := parseOTASwitch(v)
+			enabled, known := parseBoolSwitch(v)
 			if !known {
 				unknown = append(unknown, key) // 值非法：不覆盖原值，明确报给调用方
 				continue
 			}
 			NODE_OTA = enabled
+		case "access-log":
+			// 热生效：中间件在请求路径上实时读 ACCESS_LOG（见 accessLogMiddleware），
+			// 中间件本身在启动时就已挂好，所以这里改完即生效、无需重启。
+			enabled, known := parseBoolSwitch(v)
+			if !known {
+				unknown = append(unknown, key) // 值非法：不覆盖原值，明确报给调用方
+				continue
+			}
+			ACCESS_LOG = enabled
+		case "max-response-body":
+			// 热生效：改完即应用到出站客户端（applyResponseBodyLimit 内部有锁）
+			n, ok := parseByteSize(v)
+			if !ok {
+				unknown = append(unknown, key) // 值非法：不覆盖原值，明确报给调用方
+				continue
+			}
+			MAX_RESPONSE_BODY = n
+			applyResponseBodyLimit()
+		case "memory-limit":
+			// 热生效：debug.SetMemoryLimit 支持运行时调整。
+			// 0 表示"回到自动探测 cgroup"，与启动口径一致（见 resources.go）。
+			n, ok := parseByteSize(v)
+			if !ok {
+				unknown = append(unknown, key)
+				continue
+			}
+			MEMORY_LIMIT = n
+			applyMemoryLimit()
 		default:
 			unknown = append(unknown, key)
 			continue
@@ -275,7 +316,7 @@ func restartKeyValue(key string) string {
 	case "cors":
 		return CORS
 	case "ipdb":
-		return IPDB
+		return strconv.FormatBool(IPDB_ENABLED)
 	case "trusted-proxies":
 		return TRUSTED_PROXIES
 	case "ws-url":
@@ -300,7 +341,7 @@ func configSnapshot() map[string]any {
 		"single-stack":            SINGLE_STACK,
 		"dns-server":              DNS_SERVER,
 		"dnssec-server":           DNSSEC_DNS_SERVER,
-		"ipdb":                    IPDB,
+		"ipdb":                    IPDB_ENABLED,
 		"cors":                    CORS,
 		"block-private-ips":       ssrf.Enabled(),
 		"trusted-proxies":         TRUSTED_PROXIES,
@@ -309,6 +350,9 @@ func configSnapshot() map[string]any {
 		"ws-url":                  WS_URL,
 		"node-id":                 WS_NODE_ID,
 		"node-ota":                NODE_OTA,
+		"access-log":              ACCESS_LOG,
+		"max-response-body":       MAX_RESPONSE_BODY,
+		"memory-limit":            MEMORY_LIMIT,
 		"report-url":              REPORT_URL,
 		"report-interval-seconds": REPORT_INTERVAL,
 	}
@@ -388,28 +432,28 @@ func refreshRemoteConfig() (map[string]any, error) {
 // access-token 未配置时**关闭整个 HTTP 管理面**：此时节点业务接口本身也无鉴权，
 // 再暴露配置读写等于公网任何人可改节点配置。WS 通道不受影响——它由节点主动外连中间件，
 // 注册需通过中间件的 ws-keys 校验，指令只发给已注册连接，天然有鉴权。
-func registerConfigRoutes(r *gin.Engine) {
+func registerConfigRoutes(r *fiber.App) {
 	g := r.Group("/v1/config")
 	if ACCESS_TOKEN == "" {
 		slog.Warn("config HTTP API disabled: access-token not set, use WS channel instead")
-		disabled := func(c *gin.Context) {
-			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+		disabled := func(c fiber.Ctx) error {
+			return c.Status(http.StatusForbidden).JSON(fiber.Map{
 				"error": "配置管理接口已关闭：节点未配置 access-token，请通过 WS 通道操作",
 			})
 		}
-		g.GET("", disabled)
-		g.PATCH("", disabled)
-		g.POST("/refresh", disabled)
+		g.Get("", disabled)
+		g.Patch("", disabled)
+		g.Post("/refresh", disabled)
 		return
 	}
 	g.Use(tokenCheck())
-	g.GET("", configGetHandler)
-	g.PATCH("", configPatchHandler)
-	g.POST("/refresh", configRefreshHandler)
+	g.Get("", configGetHandler)
+	g.Patch("", configPatchHandler)
+	g.Post("/refresh", configRefreshHandler)
 }

-func configGetHandler(c *gin.Context) {
-	c.JSON(http.StatusOK, gin.H{
+func configGetHandler(c fiber.Ctx) error {
+	return c.Status(http.StatusOK).JSON(fiber.Map{
 		"config":              configSnapshot(),
 		"secretKeys":          sortedKeysBool(configSecretKeys),
 		"restartRequiredKeys": sortedKeysBool(configRestartKeys),
@@ -417,15 +461,13 @@ func configGetHandler(c *gin.Context) {
 	})
 }

-func configPatchHandler(c *gin.Context) {
+func configPatchHandler(c fiber.Ctx) error {
 	var body map[string]any
-	if err := c.ShouldBindJSON(&body); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "请求体须为 JSON 对象：" + err.Error()})
-		return
+	if err := c.Bind().JSON(&body); err != nil {
+		return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": "请求体须为 JSON 对象：" + err.Error()})
 	}
 	if len(body) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "请求体为空"})
-		return
+		return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": "请求体为空"})
 	}
 	// 本地显式 PATCH 不受 remote-ignore-config 限制：那是"防远端覆盖"的白名单
 	applied, unknown, restart := applyConfigMap(body, nil)
@@ -433,17 +475,16 @@ func configPatchHandler(c *gin.Context) {
 	persisted := false
 	if p := c.Query("persist"); p == "1" || strings.EqualFold(p, "true") {
 		if err := persistConfig(body, applied); err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "写回 setting.json 失败：" + err.Error(),
+			return c.Status(http.StatusInternalServerError).JSON(fiber.Map{
+				"error":   "写回 setting.json 失败：" + err.Error(),
 				"applied": applied,
 			})
-			return
 		}
 		persisted = true
 	}
 	// 未要求持久化时只改内存：需重启的键不落盘，进程重启后会回到 setting.json / 远端配置的值。
 	// 这是刻意的语义——PATCH 是"当前进程内的即时改动"，要不要固化由调用方用 persist 明确决定。
-	c.JSON(http.StatusOK, gin.H{
+	return c.Status(http.StatusOK).JSON(fiber.Map{
 		"applied":         applied,
 		"unknown":         unknown,
 		"restartRequired": restart,
@@ -452,17 +493,15 @@ func configPatchHandler(c *gin.Context) {
 	})
 }

-func configRefreshHandler(c *gin.Context) {
+func configRefreshHandler(c fiber.Ctx) error {
 	res, err := refreshRemoteConfig()
 	if err == errNoRemoteURL {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "remote-config-url 未配置，无法刷新"})
-		return
+		return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": "remote-config-url 未配置，无法刷新"})
 	}
 	if err != nil {
-		c.JSON(http.StatusBadGateway, gin.H{"error": "拉取远端配置失败：" + err.Error(), "source": REMOTE_CONFIG_URL})
-		return
+		return c.Status(http.StatusBadGateway).JSON(fiber.Map{"error": "拉取远端配置失败：" + err.Error(), "source": REMOTE_CONFIG_URL})
 	}
-	c.JSON(http.StatusOK, res)
+	return c.Status(http.StatusOK).JSON(res)
 }

 // sortedKeysBool 取 map 键的升序列表（用于向调用方说明哪些键是凭据/需重启）
@@ -0,0 +1,144 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+func contains(list []string, want string) bool {
+	for _, s := range list {
+		if s == want {
+			return true
+		}
+	}
+	return false
+}
+
+// literalString 是两条读取路径共用的「字面量 → 字符串」表，"布尔与字符串等价"就靠它。
+func TestLiteralString(t *testing.T) {
+	cases := []struct {
+		name string
+		in   any
+		want string
+	}{
+		{"nil（未配置 / null）", nil, ""},
+		{"bool false", false, "false"},
+		{"bool true", true, "true"},
+		{"字符串去首尾空白", "  no \n", "no"},
+		{"JSON 数字（float64）", float64(443), "443"},
+		{"int 0", 0, "0"},
+	}
+	for _, c := range cases {
+		if got := literalString(c.in); got != c.want {
+			t.Errorf("%s: literalString(%#v) = %q, want %q", c.name, c.in, got, c.want)
+		}
+	}
+}
+
+// parseBoolSwitch 是四个开关唯一的字面值口径。
+func TestParseBoolSwitch(t *testing.T) {
+	for _, s := range []string{"true", "TRUE", " True ", "1", "yes", "ON", "enable", "enabled"} {
+		if v, ok := parseBoolSwitch(s); !ok || !v {
+			t.Errorf("parseBoolSwitch(%q) = (%v, %v), want (true, true)", s, v, ok)
+		}
+	}
+	for _, s := range []string{"false", "FALSE", " False ", "0", "no", "off", "disable", "disabled"} {
+		if v, ok := parseBoolSwitch(s); !ok || v {
+			t.Errorf("parseBoolSwitch(%q) = (%v, %v), want (false, true)", s, v, ok)
+		}
+	}
+	// 认不出来的一律 known=false —— 绝不静默当"开"
+	for _, s := range []string{"", "   ", "banana", "tru", "2", "on!", "是", "否"} {
+		if v, ok := parseBoolSwitch(s); ok || v {
+			t.Errorf("parseBoolSwitch(%q) = (%v, %v), want (false, false)", s, v, ok)
+		}
+	}
+}
+
+// 启动路径：setting.json 里把开关写成 JSON 布尔 / 数字，读出来必须与字符串写法等价，
+// 且不能被 configString 的"空值"判断误吞（false 变成"未配置"就等于静默变回默认的"开"）。
+func TestConfigStringAcceptsJSONBoolAndNumber(t *testing.T) {
+	viper.Reset()
+	defer viper.Reset()
+	viper.SetConfigType("json")
+	if err := viper.ReadConfig(strings.NewReader(`{"ipdb": false, "access-log": 0, "port": 443, "cors": ""}`)); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := configString("ZZ_NO_IPDB", "ipdb", "true"); got != "false" {
+		t.Errorf("configString(ipdb) = %q, want \"false\"", got)
+	}
+	if configBool("ZZ_NO_IPDB", "ipdb", true) {
+		t.Error("configBool(ipdb) = true，JSON 布尔 false 被当成了「开」")
+	}
+	if configBool("ZZ_NO_ACCESS_LOG", "access-log", true) {
+		t.Error("configBool(access-log) = true，数字 0 被当成了「开」")
+	}
+	if got := configString("ZZ_NO_PORT", "port", "8080"); got != "443" {
+		t.Errorf("configString(port) = %q, want \"443\"", got)
+	}
+	if got := configString("ZZ_NO_CORS", "cors", "fallback"); got != "fallback" {
+		t.Errorf("configString(cors) = %q, want \"fallback\"（空串应视为未配置）", got)
+	}
+}
+
+// 运行路径：远端下发 / PATCH 收到布尔与字符串，行为必须一致；
+// 非法值计入 unknown 且不覆盖原值。
+func TestApplyConfigMapAcceptsBoolAndString(t *testing.T) {
+	ipdb0, access0, ota0 := IPDB_ENABLED, ACCESS_LOG, NODE_OTA
+	defer func() { IPDB_ENABLED, ACCESS_LOG, NODE_OTA = ipdb0, access0, ota0 }()
+
+	IPDB_ENABLED = true // 先置"开"，才能验证布尔 false 真的把它关掉
+	ACCESS_LOG = false  // 反向同理
+	NODE_OTA = true     // 非法值不该动它
+
+	applied, unknown, _ := applyConfigMap(map[string]any{
+		"ipdb":       false,    // JSON 布尔
+		"access-log": "true",   // 字符串
+		"node-ota":   "banana", // 非法值
+	}, nil)
+
+	if IPDB_ENABLED {
+		t.Error("ipdb：布尔 false 未生效（仍是开）")
+	}
+	if !ACCESS_LOG {
+		t.Error("access-log：字符串 \"true\" 未生效（仍是关）")
+	}
+	if !NODE_OTA {
+		t.Error("node-ota：收到非法值却把原值 true 改掉了")
+	}
+	if !contains(unknown, "node-ota") {
+		t.Errorf("unknown = %v，期望包含 node-ota", unknown)
+	}
+	for _, k := range []string{"ipdb", "access-log"} {
+		if !contains(applied, k) {
+			t.Errorf("applied = %v，期望包含 %s", applied, k)
+		}
+	}
+
+	// 反向对称：布尔 true 必须能打开、字符串 "false" 必须能关闭。
+	// 这里专门覆盖「布尔」和「字符串」两个方向，防止只测了一个方向就以为等价。
+	IPDB_ENABLED = false
+	ACCESS_LOG = true
+	applied, unknown, _ = applyConfigMap(map[string]any{
+		"ipdb":       true,
+		"access-log": "false",
+	}, nil)
+
+	if !IPDB_ENABLED {
+		t.Error("ipdb：布尔 true 未生效（仍是关）")
+	}
+	if ACCESS_LOG {
+		t.Error(`access-log：字符串 "false" 未生效（仍是开）`)
+	}
+	if len(unknown) != 0 {
+		t.Errorf("unknown = %v，期望为空", unknown)
+	}
+	for _, k := range []string{"ipdb", "access-log"} {
+		if !contains(applied, k) {
+			t.Errorf("applied = %v，期望包含 %s", applied, k)
+		}
+	}
+}
@@ -5,8 +5,7 @@ go 1.26.6
 require (
 	github.com/AdguardTeam/golibs v0.35.16
 	github.com/coder/websocket v1.8.15
-	github.com/gin-contrib/cors v1.7.7
-	github.com/gin-gonic/gin v1.12.0
+	github.com/gofiber/fiber/v3 v3.4.0
 	github.com/ip2location/ip2location-go/v9 v9.8.0
 	github.com/ipipdotnet/ipdb-go v1.3.3
 	github.com/klauspost/compress v1.19.1
@@ -21,46 +20,33 @@ require (
 )

 require (
-	github.com/bytedance/gopkg v0.1.3 // indirect
-	github.com/bytedance/sonic v1.15.0 // indirect
-	github.com/bytedance/sonic/loader v0.5.0 // indirect
-	github.com/cloudwego/base64x v0.1.6 // indirect
+	github.com/andybalholm/brotli v1.2.2 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.12 // indirect
-	github.com/gin-contrib/sse v1.1.0 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.30.1 // indirect
 	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
-	github.com/goccy/go-json v0.10.5 // indirect
-	github.com/goccy/go-yaml v1.19.2 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/gofiber/schema v1.8.0 // indirect
+	github.com/gofiber/utils/v2 v2.1.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/likexian/gokit v0.25.16 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/mattn/go-colorable v0.1.15 // indirect
+	github.com/mattn/go-isatty v0.0.22 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
-	github.com/quic-go/qpack v0.6.0 // indirect
-	github.com/quic-go/quic-go v0.59.1 // indirect
+	github.com/philhofer/fwd v1.2.0 // indirect
 	github.com/sagikazarmark/locafero v0.11.0 // indirect
 	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/cast v1.10.0 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.3.1 // indirect
-	go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
+	github.com/tinylib/msgp v1.6.4 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasthttp v1.72.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/arch v0.23.0 // indirect
 	golang.org/x/crypto v0.54.0 // indirect
 	golang.org/x/mod v0.38.0 // indirect
 	golang.org/x/net v0.57.0 // indirect
 	golang.org/x/sys v0.47.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
 	golang.org/x/tools v0.48.0 // indirect
-	google.golang.org/protobuf v1.36.11 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	lukechampine.com/uint128 v1.2.0 // indirect
 )
@@ -1,64 +1,42 @@
 github.com/AdguardTeam/golibs v0.35.16 h1:e9dyk7jfzpxMcyVZ8RktKV6JMeiQ9MpEhp/Ahm3j/R4=
 github.com/AdguardTeam/golibs v0.35.16/go.mod h1:lGsRwlo3R3ma5o8mgdDv3I+6DYTiCHfrhNyUamqhbK8=
-github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
-github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
-github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
-github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k=
-github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE=
-github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
-github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
-github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
+github.com/andybalholm/brotli v1.2.2 h1:HzTuoo2ErYQqf5qvcJInB8uvqSVxRttzkFexPWtnceM=
+github.com/andybalholm/brotli v1.2.2/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
 github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
 github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
 github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
-github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
-github.com/gin-contrib/cors v1.7.7 h1:Oh9joP463x7Mw72vhvJ61YQm8ODh9b04YR7vsOErD0Q=
-github.com/gin-contrib/cors v1.7.7/go.mod h1:K5tW0RkzJtWSiOdikXloy8VEZlgdVNpHNw8FpjUPNrE=
-github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
-github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
-github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
-github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
-github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
-github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
-github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
-github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
-github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
-github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
+github.com/fxamacker/cbor/v2 v2.9.2 h1:X4Ksno9+x3cz0TZv69ec1hxP/+tymuR8PXQJyDwfh78=
+github.com/fxamacker/cbor/v2 v2.9.2/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
 github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
 github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
-github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/gofiber/fiber/v3 v3.4.0 h1:F0aND4vwZF7dR7cbvSwFQQEpBU902XHKWxrLsFBkVqw=
+github.com/gofiber/fiber/v3 v3.4.0/go.mod h1:nAhJfdxUIJJph2tPWPmqWf8QDIN2iiqQiQf3lENZpdk=
+github.com/gofiber/schema v1.8.0 h1:NGsC9toPHmj8Xg4KpznuXBzNmHG6V5YV0tXKpKMcmis=
+github.com/gofiber/schema v1.8.0/go.mod h1:lmbXPQ8hvzXSLkdS2DS7pb4kpunC2Roh7Sj3HMjGfzA=
+github.com/gofiber/utils/v2 v2.1.1 h1:kGnoGjwEnFW6w0x45W+kLlmMJvqBGkuUA4oMWKn/T/I=
+github.com/gofiber/utils/v2 v2.1.1/go.mod h1:DdOgEVwQTi8cou/AKWPqhXOR4fHGRVhA/rEWL3IXG7Q=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/ip2location/ip2location-go/v9 v9.8.0 h1:drPzGjj1EBl45I33ErMHFtIfsQ3mR85dAQbqMDbi9mc=
 github.com/ip2location/ip2location-go/v9 v9.8.0/go.mod h1:MPLnsKxwQlvd2lBNcQCsLoyzJLDBFizuO67wXXdzoyI=
 github.com/ipipdotnet/ipdb-go v1.3.3 h1:GLSAW9ypLUd6EF9QNK2Uhxew9Jzs4XMJ9gOZEFnJm7U=
 github.com/ipipdotnet/ipdb-go v1.3.3/go.mod h1:yZ+8puwe3R37a/3qRftXo40nZVQbxYDLqls9o5foexs=
-github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
 github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
-github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
-github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
-github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 github.com/likexian/gokit v0.25.16 h1:wwBeUIN/OdoPp6t00xTnZE8Di/+s969Bl5N2Kw6bzP8=
 github.com/likexian/gokit v0.25.16/go.mod h1:Wqd4f+iifV0qxA1N3MqePJTUsmRy/lpst9/yXriDx/4=
 github.com/likexian/whois v1.15.7 h1:sajjDhi2bVD71AHJhjV7jLYxN92H4AWhTwxM8hmj7c0=
@@ -67,30 +45,26 @@ github.com/likexian/whois-parser v1.24.21 h1:MxsrGRxDOiZIVp7q7N/yAIbKuN4QAkGjCpO
 github.com/likexian/whois-parser v1.24.21/go.mod h1:o3DUruO65Pb8WXCJCTlSVkTbwuYVrBCeoMTw2q0mxY4=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20260417083004-03cc433717a7 h1:OOVHPQGWDqC8tMrwFXd4Y4VrxXEL+y77YD1Rh2dLjc0=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20260417083004-03cc433717a7/go.mod h1:sj5LMpsqB4IWdwIrcmmBJM6m+rW/uOQLSGUPhKkqdh8=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-colorable v0.1.15 h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY=
+github.com/mattn/go-colorable v0.1.15/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
+github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
 github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
 github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/oschwald/maxminddb-golang/v2 v2.3.0 h1:PnXjMGjkSQlwOBSyZ7hk6Fd75t7erkAhJNJgEhA3MQU=
 github.com/oschwald/maxminddb-golang/v2 v2.3.0/go.mod h1:NSQvgFwPxODpBTJI5+5Ns1AAucnx7ggW9PSRRifAT1s=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
+github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
-github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
-github.com/quic-go/quic-go v0.59.1 h1:0Gmua0HW1Tv7ANR7hUYwRyD0MG5OJfgvYSZasGZzBic=
-github.com/quic-go/quic-go v0.59.1/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
 github.com/rogpeppe/go-internal v1.15.0 h1:D0RCU5rMAp+SpgkiNdrjfJ+LX4J1M32V2NeCY7EJ6hc=
 github.com/rogpeppe/go-internal v1.15.0/go.mod h1:DrUVZyrJU+txYW5/1kwtXQSMFio52ZOxX7yM1VHvnxs=
 github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
 github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
+github.com/shamaton/msgpack/v3 v3.1.2 h1:d5gWAIyMU4M0WgDjz6IFSCuXJUA2dFwRHBpDclE8CLw=
+github.com/shamaton/msgpack/v3 v3.1.2/go.mod h1:DcQG8jrdrQCIxr3HlMYkiXdMhK+KfN2CitkyzsQV4uc=
 github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
 github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
 github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
@@ -101,31 +75,22 @@ github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
 github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
-github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
-github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
-github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
-go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
-go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
-go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
-go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
+github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ=
+github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.72.0 h1:R7kYdoWhn1ye1fVpP+cDHDJwYm3NkwLliwgzJ/Abg7M=
+github.com/valyala/fasthttp v1.72.0/go.mod h1:zsbLTYqcpIktdQytlVBwIjY9La5d6bs990nBxWg8efk=
+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/arch v0.23.0 h1:lKF64A2jF6Zd8L0knGltUnegD62JMFBiCPBmQpToHhg=
-golang.org/x/arch v0.23.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
 golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
 golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
 golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk=
@@ -134,19 +99,15 @@ golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
 golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
 golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
 golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
 golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
 golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
 golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
 golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
@@ -19,7 +19,7 @@ import (
 	"time"

 	"github.com/coder/websocket"
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v3"
 )

 // ==================== OTA 升级（收集中心下发，节点执行） ====================
@@ -51,22 +51,12 @@ const (
 // otaAssetBaseDefault 按版本下发且未指定 assetBase 时的默认发布地址
 const otaAssetBaseDefault = "https://github.com/nomdn/ipw-cn/releases/download"

-// parseOTASwitch 解析 OTA 开关的字面值——启动加载（ENV / setting.json）、远端下发、运行时 PATCH
-// 三处共用，保证什么算关闭的口径只有一份。
+// OTA 开关（node-ota）的字面值解析已并入 main.go 的 parseBoolSwitch —— 原先这里有一份
+// 独立的 parseOTASwitch（唯一认 yes/no 的），与 ipdb / block-private-ips / access-log
+// 各写一套，同一个字面值在四个开关上判定不一致。现在四条路径共用一张表。
 //
-// 语义是缺省允许、显式关闭（见本文件头）：true/1/yes/on 与空值都算开启，
-// false/0/no/off 算关闭。known=false 表示写法认不出来——运行时 PATCH 据此回
-// unknown 且不覆盖原值，启动期与远端下发则按缺省（允许）处理，不因一个手滑的
-// 字面值把节点锁死。
-func parseOTASwitch(raw string) (enabled, known bool) {
-	switch strings.ToLower(strings.TrimSpace(raw)) {
-	case "", "true", "1", "yes", "on":
-		return true, true
-	case "false", "0", "no", "off":
-		return false, true
-	}
-	return true, false
-}
+// 语义不变：缺省允许、显式关闭。启动时写法认不出来按缺省（允许）处理并告警，
+// 运行时 PATCH 则回 unknown 且不覆盖原值。

 // otaMu 单飞：同一时刻只允许一个 OTA 任务（重复下发直接拒绝）
 var otaMu sync.Mutex
@@ -120,35 +110,32 @@ func otaReport(c *websocket.Conn, requestID string, ok bool, stage, errMsg strin

 // registerOTARoute 注册 POST /v1/ota（收集中心 HTTP 回退通道）。
 // 鉴权与 /v1/config 一致：access-token 未配置时整个 HTTP OTA 管理面关闭（RCE 面不能裸奔）。
-func registerOTARoute(r *gin.Engine) {
+func registerOTARoute(r *fiber.App) {
 	g := r.Group("/v1/ota")
 	if ACCESS_TOKEN == "" {
 		slog.Warn("ota HTTP API disabled: access-token not set, use WS channel instead")
-		g.POST("", func(c *gin.Context) {
-			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+		g.Post("", func(c fiber.Ctx) error {
+			return c.Status(http.StatusForbidden).JSON(fiber.Map{
 				"error": "OTA 接口已关闭：节点未配置 access-token，请通过 WS 通道下发",
 			})
 		})
 		return
 	}
 	g.Use(tokenCheck())
-	g.POST("", func(c *gin.Context) {
+	g.Post("", func(c fiber.Ctx) error {
 		if !NODE_OTA {
-			c.JSON(http.StatusForbidden, gin.H{"error": "节点已禁用 OTA（node-ota=false）"})
-			return
+			return c.Status(http.StatusForbidden).JSON(fiber.Map{"error": "节点已禁用 OTA（node-ota=false）"})
 		}
 		var req otaRequest
-		if err := c.ShouldBindJSON(&req); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload: " + err.Error()})
-			return
+		if err := c.Bind().JSON(&req); err != nil {
+			return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": "invalid payload: " + err.Error()})
 		}
 		if err := otaValidate(&req); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
+			return c.Status(http.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
 		}
 		// 异步执行：下载可能耗时数分钟，HTTP 无进度通道，结果看节点日志与重连后的版本号
 		go otaRun(req, nil)
-		c.JSON(http.StatusAccepted, gin.H{"ok": true, "started": true})
+		return c.Status(http.StatusAccepted).JSON(fiber.Map{"ok": true, "started": true})
 	})
 }

@@ -12,7 +12,7 @@ import (
 	"time"

 	"github.com/coder/websocket"
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v3"
 )

 // ==================== 数据上报（节点 → 收集中心 ipw-boce） ====================
@@ -83,35 +83,8 @@ func startNodeReporter() {
 	slog.Info("node reporter enabled", "ws", WS_URL != "", "httpFallback", REPORT_URL, "interval", REPORT_INTERVAL)
 }

-// nodeReportMiddleware /v1 组统计中间件：归属规则过滤 → 计数 → 拨测类补明细
-func nodeReportMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		start := time.Now()
-		c.Next()
-
-		// 收集中心(ipw-boce)主动调度下发的拨测带 X-Scheduler-Probe 头：
-		// 该次执行由收集中心侧本地落库(source=sched/biz)，本节点跳过计数与明细上报，避免双算。
-		// 真实业务请求（用户/中间件转发）不带此头，仍按"节点是唯一记录者"正常上报。
-		if c.Request.Header.Get("X-Scheduler-Probe") != "" {
-			return
-		}
-
-		apiType, raw := nodeAPIFromPath(c)
-		if apiType == "" {
-			return
-		}
-		latency := time.Since(start)
-		status := c.Writer.Status()
-		nodeRecordAPI(apiType, status, latency)
-		if nodeIsProbeType(apiType) {
-			nodeRecordProbe(nodeProbeRec{
-				NodeID: nodeReportNodeID(), APIType: apiType, Raw: raw,
-				Query: c.Request.URL.RawQuery, Status: status, LatencyMs: latency.Milliseconds(),
-				Source: "http", CreatedAt: time.Now().Unix(),
-			})
-		}
-	}
-}
+// nodeReportMiddleware 已移至 main.go（与 tokenCheck 放在一起，见该文件「鉴权 / 上报中间件」段）。
+// 这里保留的只有上报的数据面：计数、拨测明细缓冲与周期上报。

 // nodeRecordWSProbe WS 拨测出口（ws.go wsHandleProbe 调用）。
 // 中间件已不在转发路径上计数，WS 下发的拨测同样由本节点上报（唯一记录者）；
@@ -185,9 +158,18 @@ func nodeReportNodeID() string {
 	return "unknown"
 }

-// nodeAPIFromPath 从 gin 路由模板提取 apiType 与拨测目标（对齐 WS probe 的 raw 格式）
-func nodeAPIFromPath(c *gin.Context) (apiType, raw string) {
-	path := c.FullPath() // 形如 /v1/tcping/:ip
+// nodeAPIFromPath 从 fiber 路由模板提取 apiType 与拨测目标（对齐 WS probe 的 raw 格式）。
+//
+// 路由模板经 c.Route().Path 取（形如 /v1/tcping/:ip）。fiber 的通配符不支持命名，
+// 统一是 `*`，取值走 c.Params("*")。两个 fiber 特有的坑：
+//
+//  1. c.Params / c.Route 返回的是**零拷贝字符串**（直接指向请求缓冲）。handler 执行期间
+//     这份缓冲会被复用，所以调用方必须在 c.Next() 之前取值，这里再 Clone 一道双保险。
+//  2. 通配符值**不带**前导斜杠（gin 的 `*url` 带）。原来靠 catch-all 自带 `/` 拼出
+//     "a/example.com"、"v4/example.com" 的 raw 格式，这里显式补回斜杠；detail / ssl
+//     侧原本就 TrimPrefix("/")，fiber 下该操作变成无操作，结果一致。
+func nodeAPIFromPath(c fiber.Ctx) (apiType, raw string) {
+	path := c.Route().Path
 	if !strings.HasPrefix(path, "/v1/") {
 		return "", ""
 	}
@@ -198,20 +180,21 @@ func nodeAPIFromPath(c *gin.Context) (apiType, raw string) {
 	apiType = seg[0]
 	switch apiType {
 	case "tcping", "dnssec", "whois":
-		raw = c.Param("ip")
+		raw = c.Params("ip")
 		if raw == "" {
-			raw = c.Param("domain")
+			raw = c.Params("domain")
 		}
 	case "speed":
-		raw = c.Param("version") + c.Param("url") // v4/example.com（对齐 WS probe raw 格式）
+		raw = c.Params("version") + "/" + c.Params("*") // v4/example.com（对齐 WS probe raw 格式）
 	case "dns":
-		raw = c.Param("type") + c.Param("domain") // a/example.com
+		raw = c.Params("type") + "/" + c.Params("*") // a/example.com
 	case "detail", "ssl":
-		raw = strings.TrimPrefix(c.Param("url"), "/")
+		raw = strings.TrimPrefix(c.Params("*"), "/")
 	case "location", "asn":
-		raw = c.Param("ip")
+		raw = c.Params("ip")
 	}
-	return apiType, raw
+	// Clone：切断对请求缓冲的引用（见上方说明 1）
+	return strings.Clone(apiType), strings.Clone(raw)
 }

 // nodeReportLoop 周期上报：WS 在线走 WS 广播（所有已注册中间件），否则 HTTP POST 收集中心
@@ -0,0 +1,125 @@
+package main
+
+import (
+	"log/slog"
+	"math"
+	"os"
+	"runtime/debug"
+	"strconv"
+	"strings"
+
+	"resty.dev/v3"
+)
+
+// 本文件集中放"资源上限"的处理：单次拨测的响应体上限、Go 运行时的软内存上限。
+// 起因：1c1g 节点被单个请求打爆（响应体整块进堆，见 webtest.readBodySize 注释）。
+//
+// **本文件不读配置源**（不碰 os.Getenv / viper）：配置的读取口径统一在 main.go 的 readConfig，
+// 这里只负责"拿到值之后怎么用" —— 字节后缀解析（parseByteSize）与应用到运行时（apply*）。
+
+// defaultMaxResponseBody 单次拨测响应体的默认上限（32 MiB，解压后）。
+//
+// 取 32MB 的理由：detail/speed/ssl 都只需要一个字节数，正常网页远小于此值；
+// 而节点 RAM 只有 GB 级，没有上限时一个几百 MB 的响应体就能吃掉全部内存。
+// 超过上限不是截断上报，而是直接返回错误 —— 报一个"截断后的大小/速度"比报错更误导人。
+const defaultMaxResponseBody int64 = 32 << 20
+
+// zstdMaxWindow zstd 解码窗口上限（8 MiB）。
+//
+// klauspost/compress 默认允许 512MB 窗口、64GiB 解码量，默认并发 4。窗口是在解析帧头时
+// 就按流里声明的值分配的，早于任何输出，所以 max-response-body 拦不住它 ——
+// 一条声明超大窗口的恶意 zstd 流即可让节点瞬间吃掉几百 MB。
+// HTTP 场景下正常服务端的窗口远小于此值（RFC 8878 同样建议流式场景限制窗口）。
+const zstdMaxWindow = 8 << 20
+
+// parseByteSize 解析字节数：支持裸数字与 K/M/G 后缀（KB/MB/GB、KiB/MiB/GiB 亦可），大小写不敏感。
+// 例："33554432"、"32MB"、"8MiB"、"900M"。
+func parseByteSize(s string) (int64, bool) {
+	s = strings.ToUpper(strings.TrimSpace(s))
+	if s == "" {
+		return 0, false
+	}
+	s = strings.TrimSuffix(s, "B") // 32MB -> 32M
+	s = strings.TrimSuffix(s, "I") // 32Mi -> 32M
+	if s == "" {
+		return 0, false
+	}
+	mult := int64(1)
+	switch s[len(s)-1] {
+	case 'K':
+		mult, s = 1<<10, s[:len(s)-1]
+	case 'M':
+		mult, s = 1<<20, s[:len(s)-1]
+	case 'G':
+		mult, s = 1<<30, s[:len(s)-1]
+	}
+	n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
+	if err != nil {
+		return 0, false
+	}
+	return n * mult, true
+}
+
+// applyResponseBodyLimit 把当前 MAX_RESPONSE_BODY 应用到出站客户端（启动与配置热更新都走这里）。
+// SetResponseBodyLimit 内部有锁，可与在途请求并发调用。
+func applyResponseBodyLimit() {
+	for _, c := range []*resty.Client{V4Client, V6Client} {
+		if c != nil {
+			c.SetResponseBodyLimit(MAX_RESPONSE_BODY)
+		}
+	}
+}
+
+// applyMemoryLimit 设置 Go 运行时的软内存上限（等价于 GOMEMLIMIT，可用 debug.SetMemoryLimit 热改）。
+//
+// 取值口径：读全局 MEMORY_LIMIT（启动时由 resolveByteLimit 填好，配置热更新时由
+// applyConfigMap 直接赋值）。**不要在这里再解析一次配置源** —— 那样配置热更新刚写进
+// MEMORY_LIMIT 的值会被重新解析覆盖成旧值，PATCH 静默失效。
+//
+// MEMORY_LIMIT<=0 时回落到自动探测容器限额的 90%；仍探测不到就不设置（保持 Go 默认）。
+// 目的：不设时 Go 只按 GOGC 比例回收，够不到"突增"；小内存机器上堆会一路涨到被内核 OOM kill，
+// 中间没有减速带。设了软上限后，逼近限额时 GC 会提前加密。
+// 注意软上限不是硬闸：必要时运行时仍会越过它，只是付出更多 GC 代价。
+func applyMemoryLimit() {
+	limit := MEMORY_LIMIT
+	if limit <= 0 {
+		if cg := detectCgroupMemoryLimit(); cg > 0 {
+			limit = cg / 10 * 9
+		}
+	}
+	if limit <= 0 {
+		debug.SetMemoryLimit(math.MaxInt64)
+		slog.Info("No memory limit configured or detected, runtime keeps default GC behavior")
+		return
+	}
+	debug.SetMemoryLimit(limit)
+	slog.Info("Runtime soft memory limit applied", "bytes", limit, "mb", limit>>20)
+}
+
+// detectCgroupMemoryLimit 读容器内存限额（字节）。不在容器里 / 未限额 / 读不到时返回 0。
+// cgroup v2: /sys/fs/cgroup/memory.max（无限时值为 "max"）
+// cgroup v1: /sys/fs/cgroup/memory/memory.limit_in_bytes（无限时是接近 int64 上限的大数）
+func detectCgroupMemoryLimit() int64 {
+	for _, p := range []string{
+		"/sys/fs/cgroup/memory.max",
+		"/sys/fs/cgroup/memory/memory.limit_in_bytes",
+	} {
+		raw, err := os.ReadFile(p)
+		if err != nil {
+			continue
+		}
+		s := strings.TrimSpace(string(raw))
+		if s == "" || s == "max" {
+			return 0
+		}
+		n, err := strconv.ParseInt(s, 10, 64)
+		if err != nil || n <= 0 {
+			continue
+		}
+		if n >= 1<<62 { // "无限制"的常见写法
+			return 0
+		}
+		return n
+	}
+	return 0
+}
@@ -4,18 +4,10 @@
    "single-stack": "",
    "dns-server": "",
    "dnssec-server": "",
-    "block-private-ips": true,
-    "ipdb": "false",
+    "ipdb": false,
    "cors": "",
-    "trusted-proxies": "",
-    "remote-config-url": "",
-    "remote-ignore-config": [],
    "access-token": "",
    "ws-url": "",
    "node-id": "",
-    "node-key": "",
-    "node-ota": "true",
-    "report-url": "",
-    "report-token": "",
-    "report-interval-seconds": 15
-}
+    "node-key": ""
+}
@@ -1,6 +1,13 @@
 package webtest

-import "resty.dev/v3"
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"resty.dev/v3"
+)

 // 出站 HTTP 客户端（定义与初始化仍在 main.go，启动时经 SetHTTPClient 注入）
 var v4Client, v6Client *resty.Client
@@ -18,3 +25,68 @@ func httpClient(version string) *resty.Client {
 	}
 	return v4Client
 }
+
+// newProbeRequest 构造拨测请求：开 trace（要 DNS/TCP/TLS 各段计时）、绑 context，
+// 并关掉 resty 的自动解析（SetDoNotParseResponse）—— 这一条是关键，见 readBodySize。
+//
+// 必须走这个构造函数，不要在调用点手写请求链：漏掉 DoNotParseResponse 时
+// resty 的 AutoParseResponseMiddleware 会替我们把整个响应体读进 bodyBytes
+// （Content-Type 不是 JSON/XML 时它就 readAll），响应体上限和流式计数全部失效。
+func newProbeRequest(version string, ctx context.Context) *resty.Request {
+	return httpClient(version).R().
+		EnableTrace().
+		SetContext(ctx).
+		SetDoNotParseResponse(true)
+}
+
+// readBodySize 流式读完响应体，返回**解压后**的字节数。
+//
+// 不用 resp.Bytes()：它只是把 resty 已经缓存的 bodyBytes 返回给调用方，而缓存动作
+// 发生在 Get() 内部 —— resty 的 AutoParseResponseMiddleware 对没注册解码器的
+// Content-Type（text/html、text/plain、octet-stream……差不多就是全部被测站点）
+// 会直接 res.readAll()，等价于 io.ReadAll，整个响应体留在堆上。
+// detail / speed / ssl 要的只是一个计数（page_size、download_speed），而响应体大小
+// 完全由被测站点决定：一个压缩炸弹（Content-Encoding: gzip/zstd）能把几百 KB 的响应
+// 放大到几百 MB，1c1g 节点单次请求即可 OOM。
+// 配合 newProbeRequest 的 DoNotParseResponse，这里边读边丢，内存恒定，
+// 与响应体大小无关。
+//
+// 兜底上限由客户端侧的 SetResponseBodyLimit（配置项 max-response-body）提供：
+// 超限时 resty 的 limitReadCloser 会返回 ErrReadExceedsThresholdLimit，
+// 这里转成可读的错误，而不是悄悄把截断的字节数当成页面大小报出去。
+func readBodySize(resp *resty.Response) (int64, error) {
+	if resp == nil || resp.Body == nil {
+		return 0, nil
+	}
+	n, err := io.Copy(io.Discard, resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		if errors.Is(err, resty.ErrReadExceedsThresholdLimit) {
+			return n, fmt.Errorf("response body exceeds the limit of %d bytes (max-response-body)", responseBodyLimit(resp))
+		}
+		return n, err
+	}
+	return n, nil
+}
+
+// responseBodyLimit 取本次请求实际生效的响应体上限（<=0 表示不限制）
+func responseBodyLimit(resp *resty.Response) int64 {
+	if resp == nil || resp.Request == nil {
+		return 0
+	}
+	return resp.Request.ResponseBodyLimit
+}
+
+// closeResponseBody 尽力释放失败请求的响应体。
+//
+// 为什么需要：resty 除了传输错误，还会在**响应体解压失败**时提前返回
+// （例如目标回了未注册的 Content-Encoding，client.go 里 wrapContentDecompresser 直接返回
+// ErrContentDecompresserNotFound）。这时 Response.Body 已经挂上原始响应体但没有任何人关闭，
+// 而我们随后就走 `if err != nil { return nil, err }` 把 Response 丢掉 ——
+// 每个这样的请求漏一个连接/FD，且因为 DisableKeepAlives，要等 GC 终结器才回收。
+// 目标站点只要固定回一个没注册的 Content-Encoding，就能一点点耗掉节点的 FD。
+func closeResponseBody(resp *resty.Response) {
+	if resp != nil && resp.Body != nil {
+		_ = resp.Body.Close()
+	}
+}
@@ -19,22 +19,33 @@ func SpeedTest(url string, version string) (*WebsiteSpeedTestResult, error) {
 	}

 	startTime := time.Now()
-	resp, err := httpClient(version).R().EnableTrace().SetContext(ctx).Get(url)
+	resp, err := newProbeRequest(version, ctx).Get(url)

 	fallbackToHTTP := false
 	if err != nil && strings.HasPrefix(url, "https://") {
+		closeResponseBody(resp) // 丢弃本次失败的响应，避免连接/FD 悬挂（见 closeResponseBody）
 		httpURL := strings.Replace(url, "https://", "http://", 1)
 		startTime = time.Now()
-		resp, err = httpClient(version).R().EnableTrace().SetContext(ctx).Get(httpURL)
+		resp, err = newProbeRequest(version, ctx).Get(httpURL)
 		fallbackToHTTP = true
 	}

+	if err != nil {
+		closeResponseBody(resp)
+		return nil, err
+	}
+
+	// 流式计数，不把响应体留在堆上（详见 readBodySize）。
+	// 必须放在 endTime 之前：改造前 resty 是在 Get() 内部读完整个响应体的，
+	// 所以 total_time 一直包含响应体下载耗时，download_speed 才是"字节数/总耗时"。
+	// 读体挪到 Get() 之外后若不在此处计入，total_time 会只剩到首字节的时间，
+	// download_speed 会算出几百 GB/s 这种离谱值。
+	bodySize, err := readBodySize(resp)
 	if err != nil {
 		return nil, err
 	}
 	endTime := time.Now()

-	body := resp.Bytes()
 	trace := resp.Request.TraceInfo()

 	hostRecord := CleanHostRecord(trace.RemoteAddr)
@@ -50,7 +61,7 @@ func SpeedTest(url string, version string) (*WebsiteSpeedTestResult, error) {
 	totalTime := float64(endTime.Sub(startTime).Milliseconds())
 	var downloadSpeed float64
 	if totalTime > 0 {
-		downloadSpeed = float64(len(body)) / 1024.0 / (totalTime / 1000.0)
+		downloadSpeed = float64(bodySize) / 1024.0 / (totalTime / 1000.0)
 	}
 	dumpBytes, _ := httputil.DumpResponse(resp.RawResponse, false)
 	httpStatus := resp.StatusCode()
@@ -69,7 +80,7 @@ func SpeedTest(url string, version string) (*WebsiteSpeedTestResult, error) {
 		HTTPConnectTime:  httpConnectTime,
 		FirstByteTime:    firstByteTime,
 		TotalTime:        totalTime,
-		PageSize:         int64(len(body)),
+		PageSize:         bodySize,
 		DownloadSpeed:    downloadSpeed,
 		IsReachable:      true,
 	}
@@ -19,7 +19,16 @@ func CheckSSL(url string, version string) (*SSLCheckDetail, error) {
 	}

 	startTime := time.Now()
-	resp, err := httpClient(version).R().EnableTrace().SetContext(ctx).Get(url)
+	resp, err := newProbeRequest(version, ctx).Get(url)
+	if err != nil {
+		closeResponseBody(resp)
+		return nil, err
+	}
+
+	// 流式计数，不把响应体留在堆上（详见 readBodySize）。
+	// 放在 endTime 之前：改造前 resty 在 Get() 内部就读完了整个响应体，
+	// total_time 一直包含响应体下载耗时，见 speed.go 同处注释。
+	bodySize, err := readBodySize(resp)
 	if err != nil {
 		return nil, err
 	}
@@ -29,10 +38,9 @@ func CheckSSL(url string, version string) (*SSLCheckDetail, error) {
 	hostRecord := CleanHostRecord(trace.RemoteAddr)

 	totalTime := float64(endTime.Sub(startTime).Milliseconds())
-	body := resp.Bytes()
 	var downloadSpeed float64
 	if totalTime > 0 {
-		downloadSpeed = float64(len(body)) / 1024.0 / (totalTime / 1000.0)
+		downloadSpeed = float64(bodySize) / 1024.0 / (totalTime / 1000.0)
 	}

 	rawResp := resp.RawResponse
@@ -18,23 +18,32 @@ func CheckWebsite(url string, version string) (*WebsiteCheckDetail, error) {
 	}

 	startTime := time.Now()
-	resp, err := httpClient(version).R().EnableTrace().SetContext(ctx).Get(url)
+	resp, err := newProbeRequest(version, ctx).Get(url)

 	// HTTPS 请求失败时 fallback 到 HTTP
 	fallbackToHTTP := false
 	if err != nil && strings.HasPrefix(url, "https://") {
+		closeResponseBody(resp) // 丢弃本次失败的响应，避免连接/FD 悬挂（见 closeResponseBody）
 		httpURL := strings.Replace(url, "https://", "http://", 1)
 		startTime = time.Now()
-		resp, err = httpClient(version).R().EnableTrace().SetContext(ctx).Get(httpURL)
+		resp, err = newProbeRequest(version, ctx).Get(httpURL)
 		fallbackToHTTP = true
 	}

+	if err != nil {
+		closeResponseBody(resp)
+		return nil, err
+	}
+
+	// 流式计数，不把响应体留在堆上（详见 readBodySize）。
+	// 放在 endTime 之前：改造前 resty 在 Get() 内部就读完了整个响应体，
+	// total_time 一直包含响应体下载耗时，见 speed.go 同处注释。
+	bodySize, err := readBodySize(resp)
 	if err != nil {
 		return nil, err
 	}
 	endTime := time.Now()

-	body := resp.Bytes()
 	trace := resp.Request.TraceInfo()

 	hostRecord := CleanHostRecord(trace.RemoteAddr)
@@ -50,7 +59,7 @@ func CheckWebsite(url string, version string) (*WebsiteCheckDetail, error) {
 	totalTime := float64(endTime.Sub(startTime).Milliseconds())
 	var downloadSpeed float64
 	if totalTime > 0 {
-		downloadSpeed = float64(len(body)) / 1024.0 / (totalTime / 1000.0)
+		downloadSpeed = float64(bodySize) / 1024.0 / (totalTime / 1000.0)
 	}

 	httpStatus := resp.StatusCode()
@@ -68,7 +77,7 @@ func CheckWebsite(url string, version string) (*WebsiteCheckDetail, error) {
 		HTTPConnectTime:  httpConnectTime,
 		FirstByteTime:    firstByteTime,
 		TotalTime:        totalTime,
-		PageSize:         int64(len(body)),
+		PageSize:         bodySize,
 		DownloadSpeed:    downloadSpeed,
 		IsReachable:      true,
 	}
@@ -614,63 +614,184 @@ type ASNWhoisResult struct {
 	Error       string `json:"error"`
 }

-// asnFieldPatterns 用于从原始 ASN WHOIS 文本中提取字段
-var asnFieldPatterns = map[string]*regexp.Regexp{
-	"asNumber":    regexp.MustCompile(`(?i)^\s*ASNumber\s*[:=]\s*(.+?)\s*$`),
-	"asName":      regexp.MustCompile(`(?i)^\s*ASName\s*[:=]\s*(.+?)\s*$`),
-	"asHandle":    regexp.MustCompile(`(?i)^\s*ASHandle\s*[:=]\s*(.+?)\s*$`),
-	"regDate":     regexp.MustCompile(`(?i)^\s*RegDate\s*[:=]\s*(.+?)\s*$`),
-	"updated":     regexp.MustCompile(`(?i)^\s*Updated\s*[:=]\s*(.+?)\s*$`),
-	"orgName":     regexp.MustCompile(`(?i)^\s*OrgName\s*[:=]\s*(.+?)\s*$`),
-	"orgId":       regexp.MustCompile(`(?i)^\s*OrgId\s*[:=]\s*(.+?)\s*$`),
-	"country":     regexp.MustCompile(`(?i)^\s*Country\s*[:=]\s*([A-Z]{2})\s*$`),
-	"abuseName":   regexp.MustCompile(`(?i)^\s*OrgAbuseName\s*[:=]\s*(.+?)\s*$`),
-	"abuseEmail":  regexp.MustCompile(`(?i)^\s*OrgAbuseEmail\s*[:=]\s*(.+?)\s*$`),
-	"abusePhone":  regexp.MustCompile(`(?i)^\s*OrgAbusePhone\s*[:=]\s*(.+?)\s*$`),
+// ==================== ASN WHOIS 多 RIR 解析 ====================
+//
+// QueryASNWhois 走 likexian/whois 的默认链路：先问 IANA（IANA 按 ASN 给出归属 RIR），
+// 再取该 RIR 的记录；若 ARIN 只回了「转介桩」，库会再跟一跳取到真实记录。
+// 因此 raw 里可能同时存在两段内容，且字段名随 RIR 而异：
+//
+//	ARIN   : ASNumber / ASName / OrgName / OrgId / Country / RegDate / Updated / OrgAbuse*
+//	APNIC  : aut-num / as-name / descr / country / org / last-modified（无 org-name 时组织名在 descr）
+//	RIPE   : aut-num / as-name / org / org-name / country / created / last-modified
+//	LACNIC : aut-num / owner / ownerid / country / created / changed
+//
+// 改造前只认 ARIN 字段 ⇒ 除 ARIN 注册的 ASN（Cloudflare AS13335、Google AS15169 等）外，
+// 其余 RIR 的 ASN 全部解析为空（如中国电信 AS4134 只拿到 ARIN 转介桩的 "APNIC-4134"）。
+//
+// 现在的规则：raw 里**存在 RIR 原生 aut-num 记录时一律以它为准，并整体忽略 ARIN 段**
+// （ARIN 对非 ARIN 的 ASN 只回桩，其 ASName/OrgName/OrgAbuseEmail 都是误导信息）；
+// 没有原生记录时才按 ARIN 格式解析。
+var (
+	// 原生（APNIC/RIPE/LACNIC/AFRINIC）字段
+	reASNAutNum    = regexp.MustCompile(`(?im)^\s*aut-num:\s*AS?(\d+)\s*$`)
+	reASNAsName    = regexp.MustCompile(`(?im)^\s*as-name:\s*(.+?)\s*$`)
+	reASNOrgName   = regexp.MustCompile(`(?im)^\s*org-name:\s*(.+?)\s*$`)
+	reASNOwner     = regexp.MustCompile(`(?im)^\s*owner:\s*(.+?)\s*$`)
+	reASNOwnerID   = regexp.MustCompile(`(?im)^\s*ownerid:\s*(.+?)\s*$`)
+	reASNOrgRef    = regexp.MustCompile(`(?im)^\s*org:\s*(.+?)\s*$`)
+	reASNDescr     = regexp.MustCompile(`(?im)^\s*descr:\s*(.+?)\s*$`)
+	reASNCreated   = regexp.MustCompile(`(?im)^\s*created:\s*(.+?)\s*$`)
+	reASNRegistered = regexp.MustCompile(`(?im)^\s*registered:\s*(.+?)\s*$`)
+	reASNLastMod   = regexp.MustCompile(`(?im)^\s*last-modified:\s*(.+?)\s*$`)
+	reASNChanged   = regexp.MustCompile(`(?im)^\s*changed:\s*(.+?)\s*$`)
+	reASNMailbox   = regexp.MustCompile(`(?im)^\s*abuse-mailbox:\s*(\S+@\S+)\s*$`)
+	// APNIC/RIPE 会在响应顶部给一行注释：% Abuse contact for 'AS37963' is 'xxx@yyy'
+	reASNCommentAbuse = regexp.MustCompile(`(?i)%\s*Abuse contact for '?\s*AS\d+\s*'?\s*is\s*'?([^'\s]+)'?`)
+
+	// ARIN 字段（保持改造前语义；注意：这些正则在「多行整段」文本上用，必须带 m 标志）
+	reASNNumberArin  = regexp.MustCompile(`(?im)^\s*ASNumber\s*[:=]\s*(.+?)\s*$`)
+	reASNNameArin    = regexp.MustCompile(`(?im)^\s*ASName\s*[:=]\s*(.+?)\s*$`)
+	reASNHandleArin  = regexp.MustCompile(`(?im)^\s*ASHandle\s*[:=]\s*(.+?)\s*$`)
+	reASNRegDateArin = regexp.MustCompile(`(?im)^\s*RegDate\s*[:=]\s*(.+?)\s*$`)
+	reASNUpdatedArin = regexp.MustCompile(`(?im)^\s*Updated\s*[:=]\s*(.+?)\s*$`)
+	reASNOrgNameArin = regexp.MustCompile(`(?im)^\s*OrgName\s*[:=]\s*(.+?)\s*$`)
+	reASNOrgIDArin   = regexp.MustCompile(`(?im)^\s*OrgId\s*[:=]\s*(.+?)\s*$`)
+	reASNCountryArin = regexp.MustCompile(`(?im)^\s*Country\s*[:=]\s*([A-Z]{2})\s*$`)
+	reASNAbuseName   = regexp.MustCompile(`(?im)^\s*OrgAbuseName\s*[:=]\s*(.+?)\s*$`)
+	reASNAbuseEmail  = regexp.MustCompile(`(?im)^\s*OrgAbuseEmail\s*[:=]\s*(.+?)\s*$`)
+	reASNAbusePhone  = regexp.MustCompile(`(?im)^\s*OrgAbusePhone\s*[:=]\s*(.+?)\s*$`)
+
+	// RIR 通用的「非 ASN 记录块」噪音（as-block 对象的 descr，如 "APNIC ASN block"）
+	reASNBlockNoise = regexp.MustCompile(`(?i)(^|\s)ASN? block\s*$`)
+	// 滥用联系人的对象名：RIPE 用 irt:，APNIC 的 abuse-c 对象用 role:
+	reASNRoleName = regexp.MustCompile(`(?im)^\s*(?:irt|role):\s*(.+?)\s*$`)
+	reASNPhone    = regexp.MustCompile(`(?im)^\s*phone:\s*(.+?)\s*$`)
+)
+
+// splitWhoisBlocks 按空行把响应切成记录块（每个 RIR 对象一段）
+func splitWhoisBlocks(raw string) []string {
+	raw = strings.ReplaceAll(raw, "\r\n", "\n")
+	return strings.Split(raw, "\n\n")
 }

-// parseASNWhoisRaw 从原始 ASN WHOIS 响应中解析结构化数据
-func parseASNWhoisRaw(raw string) *ASNWhoisResult {
-	result := &ASNWhoisResult{Raw: raw}
-	lines := strings.Split(raw, "\n")
-
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "%") || strings.HasPrefix(line, "#") {
-			continue
-		}
-
-		for field, pattern := range asnFieldPatterns {
-			if matches := pattern.FindStringSubmatch(line); len(matches) == 2 {
-				switch field {
-				case "asNumber":
-					result.ASNumber = matches[1]
-				case "asName":
-					result.ASName = matches[1]
-				case "asHandle":
-					if result.ASNumber == "" {
-						result.ASNumber = strings.TrimPrefix(matches[1], "AS")
-					}
-				case "regDate":
-					result.RegDate = matches[1]
-				case "updated":
-					result.Updated = matches[1]
-				case "orgName":
-					result.OrgName = matches[1]
-				case "orgId":
-					result.OrgID = matches[1]
-				case "country":
-					result.Country = matches[1]
-				case "abuseName":
-					result.AbuseName = matches[1]
-				case "abuseEmail":
-					result.AbuseEmail = matches[1]
-				case "abusePhone":
-					result.AbusePhone = matches[1]
-				}
+// pickField 按给定优先级在文本中取第一个命中的字段值；全不命中返回 ""
+func pickField(text string, patterns ...*regexp.Regexp) string {
+	for _, pattern := range patterns {
+		if m := pattern.FindStringSubmatch(text); len(m) == 2 {
+			if v := strings.TrimSpace(m[1]); v != "" {
+				return v
 			}
 		}
 	}
+	return ""
+}
+
+// findASNNativeBlock 找出含 aut-num 的原生记录块；没有返回 ""
+func findASNNativeBlock(raw string) string {
+	for _, block := range splitWhoisBlocks(raw) {
+		if reASNAutNum.MatchString(block) {
+			return block
+		}
+	}
+	return ""
+}
+
+// findASNOrgBlock 按原生块里的 org: 句柄定位对应的 organisation/owner 对象
+// （RIPE 的 org-name 与 country 不在 aut-num 对象里，而在 organisation 对象里）
+func findASNOrgBlock(raw, nativeBlock string) string {
+	handle := pickField(nativeBlock, reASNOrgRef)
+	if handle == "" {
+		return ""
+	}
+	for _, block := range splitWhoisBlocks(raw) {
+		if strings.Contains(block, handle) && (reASNOrgName.MatchString(block) || reASNOwner.MatchString(block)) {
+			return block
+		}
+	}
+	return ""
+}
+
+// findASNOrgName 取组织名：organisation 对象的 org-name/owner（RIPE/APNIC/JPNIC）
+// → 原生块首行 descr（APNIC 常见，如 "Hangzhou Alibaba Advertising Co.,Ltd."），并过滤 block 噪音
+func findASNOrgName(orgBlock, nativeBlock string) string {
+	if v := pickField(orgBlock, reASNOrgName, reASNOwner); v != "" {
+		return v
+	}
+	for _, m := range reASNDescr.FindAllStringSubmatch(nativeBlock, -1) {
+		v := strings.TrimSpace(m[1])
+		if v == "" || reASNBlockNoise.MatchString(v) {
+			continue
+		}
+		return v
+	}
+	return ""
+}
+
+// findASNCommentAbuseEmail 取响应顶部注释里的 Abuse 邮箱（APNIC/RIPE 提供）
+func findASNCommentAbuseEmail(raw string) string {
+	if m := reASNCommentAbuse.FindStringSubmatch(raw); len(m) == 2 {
+		return strings.TrimSpace(m[1])
+	}
+	return ""
+}
+
+// findASNMailboxAbuse 取含 abuse-mailbox 的记录块里的联系人名与电话（RIPE 的 irt:、APNIC 的 role:）
+func findASNMailboxAbuse(raw string) (name, email, phone string) {
+	for _, block := range splitWhoisBlocks(raw) {
+		mailbox := pickField(block, reASNMailbox)
+		if mailbox == "" {
+			continue
+		}
+		return pickField(block, reASNRoleName), mailbox, pickField(block, reASNPhone)
+	}
+	return "", "", ""
+}
+
+// parseASNWhoisRaw 从原始 ASN WHOIS 响应中解析结构化数据（多 RIR）
+func parseASNWhoisRaw(raw string) *ASNWhoisResult {
+	result := &ASNWhoisResult{Raw: raw}
+
+	// 情况一：有 RIR 原生记录（APNIC/RIPE/LACNIC/AFRINIC），只认它
+	if nativeBlock := findASNNativeBlock(raw); nativeBlock != "" {
+		orgBlock := findASNOrgBlock(raw, nativeBlock)
+		result.ASNumber = pickField(nativeBlock, reASNAutNum, reASNNumberArin)
+		result.ASName = pickField(nativeBlock, reASNAsName)
+		result.OrgName = findASNOrgName(orgBlock, nativeBlock)
+		result.OrgID = pickField(nativeBlock, reASNOrgRef, reASNOwnerID)
+		result.Country = pickField(nativeBlock, reASNCountryArin)
+		if result.Country == "" {
+			result.Country = pickField(orgBlock, reASNCountryArin)
+		}
+		result.RegDate = pickField(nativeBlock, reASNCreated, reASNRegistered, reASNRegDateArin)
+		result.Updated = pickField(nativeBlock, reASNLastMod, reASNUpdatedArin, reASNChanged)
+
+		// 滥用联系人：先用注释行（最权威），再用 abuse-mailbox 所在对象
+		result.AbuseEmail = findASNCommentAbuseEmail(raw)
+		name, email, phone := findASNMailboxAbuse(raw)
+		if result.AbuseName == "" {
+			result.AbuseName = name
+		}
+		if result.AbuseEmail == "" {
+			result.AbuseEmail = email
+		}
+		result.AbusePhone = phone
+		return result
+	}
+
+	// 情况二：ARIN 格式（ARIN 自有的 ASN），保持改造前行为
+	result.ASNumber = pickField(raw, reASNNumberArin)
+	if result.ASNumber == "" {
+		result.ASNumber = strings.TrimPrefix(pickField(raw, reASNHandleArin), "AS")
+	}
+	result.ASName = pickField(raw, reASNNameArin)
+	result.OrgName = pickField(raw, reASNOrgNameArin)
+	result.OrgID = pickField(raw, reASNOrgIDArin)
+	result.Country = pickField(raw, reASNCountryArin)
+	result.RegDate = pickField(raw, reASNRegDateArin)
+	result.Updated = pickField(raw, reASNUpdatedArin)
+	result.AbuseName = pickField(raw, reASNAbuseName)
+	result.AbuseEmail = pickField(raw, reASNAbuseEmail)
+	result.AbusePhone = pickField(raw, reASNAbusePhone)

 	return result
 }
@@ -37,7 +37,7 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		testURL := normalizeURL(raw)
 		if cached, ok := websiteCache.Load(testURL); ok {
 			entry := cached.(websiteCacheEntry)
-			if time.Since(entry.timestamp) < 5*time.Minute {
+			if time.Since(entry.timestamp) < cacheTTL(entry.failed) {
 				return 200, entry.result
 			}
 			websiteCache.Delete(testURL)
@@ -52,14 +52,17 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 			},
 		)
 		result := &WebsiteCheckResult{IPv4: ipv4, IPv6: ipv6}
-		websiteCache.Store(testURL, websiteCacheEntry{result: result, timestamp: time.Now()})
+		failed := dualAnyFailed(result.IPv4, result.IPv6, func(d *webtest.WebsiteCheckDetail) bool {
+			return d != nil && !d.IsReachable
+		})
+		websiteCache.Store(testURL, websiteCacheEntry{result: result, timestamp: time.Now(), failed: failed})
 		return 200, result

 	case "ssl":
 		testURL := normalizeURL(raw)
 		if cached, ok := sslCache.Load(testURL); ok {
 			entry := cached.(sslCacheEntry)
-			if time.Since(entry.timestamp) < 5*time.Minute {
+			if time.Since(entry.timestamp) < cacheTTL(entry.failed) {
 				return 200, entry.result
 			}
 			sslCache.Delete(testURL)
@@ -74,7 +77,10 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 			},
 		)
 		result := &SSLCheckResult{IPv4: ipv4, IPv6: ipv6}
-		sslCache.Store(testURL, sslCacheEntry{result: result, timestamp: time.Now()})
+		failed := dualAnyFailed(result.IPv4, result.IPv6, func(d *webtest.SSLCheckDetail) bool {
+			return d != nil && !d.IsReachable
+		})
+		sslCache.Store(testURL, sslCacheEntry{result: result, timestamp: time.Now(), failed: failed})
 		return 200, result

 	case "speed":
@@ -87,7 +93,7 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		cacheKey := fmt.Sprintf("%s:%s", testURL, version)
 		if cached, ok := speedCache.Load(cacheKey); ok {
 			entry := cached.(speedCacheEntry)
-			if time.Since(entry.timestamp) < 5*time.Minute {
+			if time.Since(entry.timestamp) < cacheTTL(entry.failed) {
 				return 200, entry.result
 			}
 			speedCache.Delete(cacheKey)
@@ -95,7 +101,7 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		r, e := webtest.SpeedTest(testURL, version)
 		if e != nil {
 			errorResult := &webtest.WebsiteSpeedTestResult{HostRecord: "Error: " + e.Error()}
-			speedCache.Store(cacheKey, speedCacheEntry{result: errorResult, timestamp: time.Now()})
+			speedCache.Store(cacheKey, speedCacheEntry{result: errorResult, timestamp: time.Now(), failed: true})
 			return 200, errorResult
 		}
 		speedCache.Store(cacheKey, speedCacheEntry{result: r, timestamp: time.Now()})
@@ -123,7 +129,7 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		cacheKey := fmt.Sprintf("%s:%s:%d", host, port, n)
 		if cached, ok := pingCache.Load(cacheKey); ok {
 			entry := cached.(pingCacheEntry)
-			if time.Since(entry.timestamp) < 5*time.Minute {
+			if time.Since(entry.timestamp) < cacheTTL(entry.failed) {
 				return 200, entry.result
 			}
 			pingCache.Delete(cacheKey)
@@ -138,7 +144,9 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 			},
 		)
 		result := &TCPingResult{IPv4: ipv4, IPv6: ipv6}
-		pingCache.Store(cacheKey, pingCacheEntry{result: result, timestamp: time.Now()})
+		// 只有双栈都失败才算整体失败，单侧失败仍返回了可用的延迟数据（口径同 HTTP handler）
+		failed := tcpingFailed(ipv4) && tcpingFailed(ipv6)
+		pingCache.Store(cacheKey, pingCacheEntry{result: result, timestamp: time.Now(), failed: failed})
 		return 200, result

 	case "dns":
@@ -190,7 +198,7 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		}
 		if cached, ok := whoisCache.Load(raw); ok {
 			entry := cached.(whoisCacheEntry)
-			if time.Since(entry.timestamp) < 5*time.Minute {
+			if time.Since(entry.timestamp) < cacheTTL(entry.failed) {
 				return 200, entry.result
 			}
 			whoisCache.Delete(raw)
@@ -226,9 +234,9 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		} else if errStr, ok := result["dbip_asn"].(string); ok {
 			asnResult["dbip_asn"] = map[string]string{"error": errStr}
 		}
-		if maxmindASN, ok := result["maxmind_asn"].(*ipdb.MMDBASNResult); ok {
-			whoisData, err := webtest.QueryASNWhois(maxmindASN.ASN)
-			if err == nil {
+		// WHOIS 进一步解析（与 /v1/asn/:ip 走同一套兜底与缓存）
+		if asn := resolveASN(result); asn != "" {
+			if whoisData, ok := lookupASNWhois(asn); ok {
 				asnResult["whois"] = whoisData
 			}
 		}
Author	SHA1	Message	Date
nomdn	805b65bc07	fix(node): ASN WHOIS 支持多 RIR 解析，补 ASN 库兜底与缓存键归一化现象：/v1/asn/:ip 与 ws 的 asn 路径，除 1.1.1.1（AS13335，ARIN 注册）外全部拿不到 whois 信息。解析侧 src/webtest/whois.go - 根因：parseASNWhoisRaw 只认 ARIN 字段名（ASNumber/ASName/OrgName/OrgAbuse*），而 QueryASNWhois 走 IANA → 归属 RIR 链路，非 ARIN 的 ASN 回的是 aut-num/ as-name/descr/country/last-modified 格式，于是字段解析全空 - 另一坑：ARIN 对非 ARIN 资源只回转介桩（ASName: APNIC-4134 + ReferralServer），同一条 raw 里存在两段内容，桩的字段是误导信息 - 改为按空行分块解析：存在原生 aut-num 块时以它为准、整体忽略 ARIN 段；字段按 RIR 分级取值（RIPE 的组织名与国别按 aut-num 的 org: 句柄定位 organisation 对象） - abuse 优先取 % Abuse contact 注释行，其次含 abuse-mailbox 的对象 - 实网验证 22/22 全解析（电信/联通/移动/阿里/腾讯/百度/华为 + CF/Google/Amazon/ Hetzner/Linode 等），覆盖 ARIN+APNIC+RIPE 三类 RIR 消费侧 src/main.go src/ws.go - 新增 resolveASN()：ASN 来源按 maxmind → dbip → ip2location 逐级兜底。此前只认 maxmind_asn，某 IP 未命中该库时整段 whois 直接消失，哪怕另两个库有数据 - 新增 normalizeASN()：MMDBASNResult.ASN 自带 "AS" 前缀，ip2location 的 asn 是裸数字，缓存键与查询入参统一归一化（此前 "AS"+ASN 实际拼成 ASAS13335） - 新增 lookupASNWhois()：handler 与 ws 共用同一套缓存 —— ws 路径此前完全没有缓存，每个请求都真查一次 WHOIS - 新增 asnWhoisFailed()：likexian/whois 出错时返回 (result, nil)，错误塞在 result.Error 里；老代码只判 err != nil（恒为假）⇒ 失败结果被当成功缓存 5min，现按失败走 30s TTL	2026-10-05 20:51:01 +08:00
nomdn	682983e411	fix(frontend-ssr): 手机端两 IP 块间大空隙——min-height 只留给 IPv6 行，IP 行 margin 归零 - 窄屏 .ip-row 一刀切 min-height:75px 使 IPv4 行（1 行 30px）下部空出 ~45px，与 style.css 窄屏 .one-line 的 0.5em margin 叠加成大段空白 - IPv6 行拆出 ip-row-v6 类单独吃 75px 预留（align-content:flex-start 防行间拉伸） - 窄屏 .ip-row margin:0 盖掉 .one-line 的 0.5em（scoped 特异性更高） - IPv4 回填前后均 1 行 30px，高度不变，不引入新 CLS - CDP 实测（412 宽）：两行空隙 61px → 0px，IP 回填正常	2026-10-05 09:58:18 +08:00
nomdn	19fe134762	perf(frontend-ssr): modulepreload 降级+探测提前+关 appManifest+链接色达标，LH desktop 100 - compress-html: modulepreload 注入 fetchpriority=low，render-blocking CSS 先行（mobile FCP 2345→1109ms，三档实测 low 最优：medium 仍挤 CSS 净亏） - index.vue: 三个 IP 探测 fetch 从 onMounted 提前到 head 内联脚本（实测 392ms 发出，旧时序要等水合 ~2000ms），结果挂 window.__ipProbe + ip-probe 事件，onMounted 只消费 - nuxt.config: experimental.appManifest=false，不再请求 builds/meta/<id>.json， NUXT_E5002 从源头消失（本地「服务旧磁盘新」与线上发版瞬间均免疫） - 链接色 --link-color 变量：亮 #1d7a4a（白底 5.34:1 过 axe 4.5 线），暗保持 #299764， style.css 六处硬编码色值收口 - LH 13.5：desktop 100/99/100（TBT 14-53ms），mobile 干净轮 92-96；A11y/BP 全程 100	2026-10-05 01:56:25 +08:00
nomdn	5445b4df64	revert(frontend-ssr): 撤回文档内容图片宽高注入回退 `243060a` 中的图片治理部分：markdown.ts 移除 width/height 注入与 doc-image-dims.json 构建期清单，package.json/pnpm-lock 去 image-size 依赖。	2026-10-05 01:56:24 +08:00
nomdn	4f6cf7fac7	chore(frontend): 移除 frontend-svelte 前端目录整目录删除（SvelteKit 3 + adapter-cloudflare）。注意：.github/workflows/frontend-svelte.yml 仍保留，其 paths 过滤 frontend-svelte/** 在目录删除后不再触发，属死文件，去留待定。	2026-10-05 01:55:57 +08:00
nomdn	243060a32a	perf(frontend-ssr): 修文档页移动端 500，LH 拉升至 95/86/93，主题色改 #299764 一揽子水合修复 + 性能优化 + 品牌色更换： - 修 P0：/doc/** 撤预渲染改回 SSR——预渲染 HTML 恒为宽屏，真机 UA 下客户端窄屏判定与之失配导致整页 500。窄屏判定收口到 composables/useShellNarrow.ts（服务端按 sec-ch-ua-mobile/UA 判、客户端沿用序列化值、爬虫强制宽屏），移动端 /doc 恢复 200 且水合成本大降 - 图片治理：markdown 渲染注入 loading=lazy + decoding=async + 真实宽高；尺寸清单 config/doc-image-dims.json 由 nuxt.config 构建期扫 public/ 生成（CF Workers 无 fs，只能构建期算），unsized-images fail→pass - 源站压缩：compressPublicAssets（142 个 .gz/.br）+ server/plugins/ compress-html.ts（SSR HTML 按 Accept-Encoding 回 br/gzip，首页 35KB→7.5KB），消除 Lantern 无压缩高估 - a11y：/dns 的 el-select 补 aria-label（92→97） - NuxtLink 预取改 interaction（省 idle 期观察者任务，ssl TBT 370→120ms） - 主题色全局 #3EAF7C → #299764（17 文件 38 处，白底对比 2.75→3.68:1） LH 实证（mobile）：/ 67→95、/dns 61→86、/ssl 57→93；桌面 / 100、/dns 99、 /ssl 98。零新增 fail；unsized-images、unused-css/js、interactive、 speed-index 等一批 fail→pass。剩余 fail：bf-cache（LH 内部错误）、 color-contrast（品牌绿 3.68:1，需 4.5:1，知情保留）、TBT（页面 chunk 求值+水合地板，再降需组件级懒水合，UX 有损暂缓）。	2026-10-04 15:49:16 +08:00
nomdn	924b9bcc36	style(frontend-svelte): 还原原版 Element Plus 观感，图标改用本地 EP 图标把迁移到 SvelteKit 后走样的 UI 逐项改回 nipw.cn 的 element-plus 观感；所有数值都以线上原版的 computed style 为准（下载 live CSS 用脚本遍历 document.styleSheets 逐条 trace 命中规则），不靠读源码猜。 - 字体：font-family 还原成 UA 默认（不再落到细体）；补齐标题的 UA 外边距 - 顶栏：60px 高 + 1px 底线；项 padding 0 20px（文字起点 +30px）、14px、#303133 - 文档菜单：56px/50px 行高、20px/40px 逐层缩进、选中用 EP 蓝 #409eff、分组箭头 12px 且颜色继承标题 - /doc 几何对齐：body 外边距归零（.doc-route 门控，离开路由自动摘除）、正文容器 margin-top 40px → 正文首行 y=120、侧栏 260px 与原版完全一致 - 输入框 16px、按钮 font-weight 400、圆角统一 4px（不再是大圆角） - 链接色：正文 #2f7d5a（深色 #3eaf7c）；文档锚点用「非分层 + 更高特异性」压过 github-markdown-css 的 .markdown-body a - 图标：新增本地 Element Plus 图标组件（几何取自 @element-plus/icons-vue@2.3.2），配 scripts/extract-element-plus-icons.mjs 生成；去掉 @lucide/svelte 依赖（同步 bun.lock） - EP 变量（--el-*）收拢在 site.css 的 :root，与 element-plus 源码逐条对应实证：/ssl 与 / 在 1440×900 下与原版逐像素一致；/doc 正文 y=120、侧栏与菜单项（56px/50px、箭头 t=138 l=227 12px #303133）与原版完全一致；375×812 下单一汉堡、无横向溢出。bun run check 0 error 0 warning。	2026-10-04 03:38:51 +08:00
nomdn	611caa30f6	feat(frontend): 新增 SvelteKit 3 前端 frontend-svelte，接管 ipw-cn Worker 把 frontend-ssr（Nuxt 4 全栈）整体迁移到 SvelteKit 3 + Svelte 5，包管理用 bun，组件库 shadcn-svelte。18 条路由 + 5 个 server endpoint 全部跑通。迁移内容 - 12 个工具页（location/asn/whois/ssl/ipv6webcheck/dns/dnssec/tcping/ipv6tcping/ speedtest/ipv6speedtest/screenshot）+ 首页 + 页头页脚 + 文档站 - server 路由：/ip、/ip/[ip]、/api/markdown/[...path]、/api/whois/[domain]、 /middleware/[...slug]（内置中间件兜底转发，含 403/429 与路径穿越防护） - lib 收口：node-pool（单成功重试 / 多节点并发）、visitor-ip、ui-classes、 TcpingPanel/SpeedtestPanel（v4/v6 共用）、server/docs（36 篇 md 构建期内联） - 部署：adapter-cloudflare + wrangler.jsonc；CI 新增 frontend-svelte.yml （bun + wrangler deploy --keep-vars），frontend-ssr.yml 去掉 push 触发运行时实证中修掉的问题（构建期均不可见） - TcpingPanel/SpeedtestPanel 用了 untrack 但未 import ⇒ 4 个页面 SSR 500 - middleware 路由的 API_KEYS/APIKEYS 是裸标识符 ⇒ 运行时 ReferenceError，改为从 $app/env/private 导入（Kit 3；$env/dynamic/private 已废弃） - 补 /doc/** 的 SSG（对齐旧站 routeRules.prerender）：32 个 html； DocMenu 折叠改用 hidden，否则预渲染爬虫抓不到子树 - app.html 内联脚本在预渲染页拿不到 CSP hash（Kit 只 hash 组件内联脚本），改为构建期现算 sha256 注入 script-src，避免深色模式首屏脚本被拦 - 修正 16 处历史遗留的文档目录锚点（旧站同样存在，Nitro 不校验锚点）验证：bun run check 0 error；wrangler dev 下 18 条路由全 200；SSR 页 CSP 走响应头 + nonce，SSG 页走 <meta> + hash 且两个内联脚本均被覆盖；middleware 的 Authorization 注入用本地 echo 上游实测通过；无 API_KEYS 时优雅降级。另外把链接颜色改回品牌绿 #3eaf7c（frontend-ssr 同步）。	2026-10-04 00:44:24 +08:00
nomdn	a8f7f2bd17	refactor(node): 配置字面量归一成一张表，布尔与字符串彻底等价 - 新增 literalString 作为两条读取路径唯一的「字面量 → 字符串」表：启动路径（setting.json 经 viper / 环境变量）与运行路径（远端下发 / PATCH）共用，取代原先「viper 隐式 cast + configValue 里手写 type switch」两套规则 —— 二者只是碰巧一致，任一边不认布尔，ipdb: false 就会静默变回「开」 - configValue 收敛为一行；configString 的 setting.json 一侧改走 viper.Get 后归一，于是布尔 false / 数字 0 / 字符串 "false" 三种写法现在必然等价 - 新增 src/config_switch_test.go（仓库首个测试文件）：覆盖 literalString、 parseBoolSwitch（含 8 个非法值）、启动路径的布尔与数字写法、运行路径布尔与字符串的双向对称（布尔 true 开 / 字符串 "false" 关） - parseBoolSwitch 签名不变，注释明确入参是「已归一」的字符串，职责更干净对外行为不变：入口仍宽容接收布尔 / 字符串 / 数字，出口 GET /v1/config 的 ipdb 恒为 JSON 布尔；「空串 / null = 未提，不等于 false」的口径保持不变。 docs：config.md 补数字写法与「四条来源先归一成同一张表再判定」的口径说明	2026-10-03 17:52:59 +08:00
nomdn	ff5caddab3	refactor(node): 四个开关统一字面值口径，新增 access-log 热开关 - 新增 access-log / ACCESS_LOG（缺省开）：开关判定放在请求路径上， PATCH /v1/config 与远端下发改完即生效；关闭时中间件直接短路放行，连 logger 的计时与字段拼接都不做（访问日志是每请求一次同步写） - 引入 parseBoolSwitch 作为 ipdb / block-private-ips / node-ota / access-log 四个开关唯一的字面值解析表，替换口径互不相同的 configDisabled 与 parseOTASwitch：认不出的值不再静默当成"开"，启动阶段告警并落默认值， PATCH / 远端下发计入应答的 unknown 并保留原值 - setting.json.example 收敛为最小可用集（11 键），其余以文档为准 BREAKING CHANGE: ipdb 由字符串改为布尔（IPDB string -> IPDB_ENABLED bool）。 /v1/config 的 ipdb 返回 boolean，setting.json 里写 false 而不是 "false"；同时 ipdb 不再大小写敏感，"False" / "no" 由原来的"开"变为"关"。 docs：config.md 补四个开关的统一口径、22 个字段与环境变量清单	2026-10-03 17:23:45 +08:00
nomdn	a00e42a896	feat(frontend): 首屏性能与可访问性打磨，缓存控制交 CDN 侧性能（Lighthouse 驱动）： - 代码高亮改在 SSR 期算完（index / location 走 useAsyncData），客户端不再下载执行 shiki；配合 build:manifest 抹掉 prefetch 标记，首页少白下 165KB - 三个 IP 探测源站 preconnect（crossorigin）、中间件 dns-prefetch，把握手提前到 HTML 解析期 - runtimeConfig.public 移除 docConfig（每页 HTML 少背约 4.5KB），改成直接 import - el-image 换原生 img 并补宽高：SSR 不再只吐占位 div，顺带治图片重排 - routeRules 不再设置任何 cache-control，缓存策略交给前置 CDN 可访问性： - el-divider 换 aria-hidden 原生分隔线，并压制 EP Menu.init 写入的 tabindex - 水平菜单项内层 a 撑满 li，满足 target-size（24x24） - logo 链接补条件 aria-label；代码注释 / 副标题 / 链接颜色对比度达标 docs：deploy-frontend.md 移除缓存策略一节（缓存由 CDN 侧控制）	2026-10-03 17:23:32 +08:00
nomdn	031c1e8b69	feat(ci): 优化构建和发布流程，支持并行构建和版本元数据计算	2026-10-01 16:53:51 +08:00
nomdn	bb02b0c5bd	feat(install): 支持非 root 安装，install.sh 询问降级、contribute.sh 静默降级 - install.sh：非 root 时提示并询问是否改用 systemd --user（答 n/回车取消），支持 --user/--system 显式指定；用户级 unit 落 ~/.config/systemd/user，去掉 User= 与 network-online 依赖、改 WantedBy=default.target，并在装后启用 linger - contribute.sh：保持"零交互"定位，非 root 且未指定作用域时直接静默降级为用户级（不打断询问），仅显式 --system 在非 root 下报错 - 两个脚本作用域敏感的调用统一收进 sc()/jc() 包装，避免漏掉 --user 后查到的其实是系统级命名空间（空结果）	2026-10-01 16:27:04 +08:00
nomdn	e7365e3005	fix(frontend): ASN 页去掉重复的 AS 前缀，后端返回值已自带	2026-10-01 15:13:48 +08:00
nomdn	1b0f2646fe	refactor(node): 迁移到 Fiber v3、收敛配置读取，修拨测内存放大并重定缓存 TTL - HTTP 层 gin → Fiber v3：路由与中间件接线全部收进 newFiberApp，main 只按步骤调用；补齐 fiber 不带的访问日志（转投 slog）与 panic 兜底，上报中间件并入 main.go 与 tokenCheck 并列 - 配置读取收敛到 main.go 的 readConfig（env > setting.json > 默认值），其余文件不再直接读配置；新增 max-response-body / memory-limit，两者都支持运行中热更新 - 修响应体内存放大：拨测请求统一走 SetDoNotParseResponse，响应体只计数不读入内存； zstd 解码器收紧窗口与并发，堵住按帧头声明值预分配导致的内存放大 - 缓存改为按条目标记：成功 30s、失败 5s（原为成功 5 分钟、失败靠后台协程 30s 后删）；失败判定收进 tcpingFailed / dualAnyFailed，HTTP 与 WS 两条入口共用同一套口径，并补上 tcping "拨号全失败"漏判为成功的口子	2026-10-01 15:13:39 +08:00
nomdn	31d725ff84	feat: 添加贡献节点脚本并更新安装脚本以支持 IP 数据库和中间件地址配置	2026-09-26 20:11:23 +08:00
nomdn	21fa445ff8	Merge branch 'main' of https://github.com/nomdn/ipw-cn	2026-09-26 20:03:19 +08:00
nomdn	e7cccfbd99	Fix typo in label property	2026-09-26 15:14:10 +08:00
nomdn	f12c97cf8b	Update index.ts	2026-09-26 14:56:12 +08:00
nomdn	cc8690d264	fix(install): systemd 单元里路径不再加引号，并拦截含空格的安装目录 systemd 的 WorkingDirectory/ExecStart 不按 shell 规则解析，写成 WorkingDirectory="…" 会把引号当作字面量的一部分；而路径含空白时，裸写又会被拆成多个参数。两种写法都会让服务起不来。这里改为裸写路径，并在交互采集安装目录时提前拒绝含空格/制表符的输入，直接给出明确报错而不是事后看 systemd 报错。 Environment= 那处仍保留引号（systemd 对 Environment 的引号是有语义的，与 WorkingDirectory/ExecStart 不同）。	2026-09-26 12:50:41 +08:00
nomdn	b705dbdc18	Merge branch 'main' of https://github.com/nomdn/ipw-cn	2026-09-25 21:09:06 +08:00
nomdn	25a8d7a651	Merge pull request #34 from nomdn/dependabot/npm_and_yarn/docs/vite-5.4.21 chore(deps): bump vite from 5.4.14 to 5.4.21 in /docs	2026-09-19 23:34:55 +08:00
dependabot[bot]	f44da9a467	chore(deps): bump vite from 5.4.14 to 5.4.21 in /docs Bumps [vite](https://github.com/vitejs/vite/tree/HEAD/packages/vite) from 5.4.14 to 5.4.21. - [Release notes](https://github.com/vitejs/vite/releases) - [Changelog](https://github.com/vitejs/vite/blob/v5.4.21/packages/vite/CHANGELOG.md) - [Commits](https://github.com/vitejs/vite/commits/v5.4.21/packages/vite) --- updated-dependencies: - dependency-name: vite dependency-version: 5.4.21 dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>	2026-09-19 00:57:19 +00:00