.cargo/deny.toml

@@ -1,15 +0,0 @@
-[bans]
-multiple-versions = "deny"
-wildcards = "allow"
-highlight = "all"
-
-# Explicitly flag the weak cryptography so the agent is forced to justify its existence
-[[bans.skip]]
-name = "md-5"
-version = "*"
-reason = "MUST VERIFY: Only allowed for legacy checksums, never for security."
-
-[[bans.skip]]
-name = "sha1"
-version = "*"
-reason = "MUST VERIFY: Only allowed for backwards compatibility."

.dockerignore

@@ -1,8 +0,0 @@
-.git
-.github
-target
-.kilocode
-cache
-tlsfront
-*.tar
-*.tar.gz

.github/codeql/codeql-config.yml

@@ -7,16 +7,7 @@ queries:
   - uses: security-and-quality
   - uses: ./.github/codeql/queries
 
-paths-ignore:
-  - "**/tests/**"
-  - "**/test/**"
-  - "**/*_test.rs"
-  - "**/*/tests.rs"
 query-filters:
-  - exclude:
-      tags:
-        - test
-
   - exclude:
       id:
         - rust/unwrap-on-option

.github/instructions/Architecture.instructions.md

@@ -1,126 +0,0 @@
-# Architecture Directives
-
-> Companion to `Agents.md`. These are **activation directives**, not tutorials.
-> You already know these patterns — apply them. When making any structural or
-> design decision, run the relevant section below as a checklist.
-
----
-
-## 1. Active Principles (always on)
-
-Apply these on every non-trivial change. No exceptions.
-
-- **SRP** — one reason to change per component. If you can't name the responsibility in one noun phrase, split it.
-- **OCP** — extend by adding, not by modifying. New variants/impls over patching existing logic.
-- **ISP** — traits stay minimal. More than ~5 methods is a split signal.
-- **DIP** — high-level modules depend on traits, not concrete types. Infrastructure implements domain traits; it does not own domain logic.
-- **DRY** — one authoritative source per piece of knowledge. Copies are bugs that haven't diverged yet.
-- **YAGNI** — generic parameters, extension hooks, and pluggable strategies require an *existing* concrete use case, not a hypothetical one.
-- **KISS** — two equivalent designs: choose the one with fewer concepts. Justify complexity; never assume it.
-
----
-
-## 2. Layered Architecture
-
-Dependencies point **inward only**: `Presentation → Application → Domain ← Infrastructure`.
-
-- Domain layer: zero I/O. No network, no filesystem, no async runtime imports.
-- Infrastructure: implements domain traits at the boundary. Never leaks SDK/wire types inward.
-- Anti-Corruption Layer (ACL): all third-party and external-protocol types are translated here. If the external format changes, only the ACL changes.
-- Presentation: translates wire/HTTP representations to domain types and back. Nothing else.
-
----
-
-## 3. Design Pattern Selection
-
-Apply the right pattern. Do not invent a new abstraction when a named pattern fits.
-
-| Situation | Pattern to apply |
-|---|---|
-| Struct with 3+ optional/dependent fields | **Builder** — `build()` returns `Result`, never panics |
-| Cross-cutting behavior (logging, retry, metrics) on a trait impl | **Decorator** — implements same trait, delegates all calls |
-| Subsystem with multiple internal components | **Façade** — single public entry point, internals are `pub(crate)` |
-| Swappable algorithm or policy | **Strategy** — trait injection; generics for compile-time, `dyn` for runtime |
-| Component notifying decoupled consumers | **Observer** — typed channels (`broadcast`, `watch`), not callback `Vec<Box<dyn Fn>>` |
-| Exclusive mutable state serving concurrent callers | **Actor** — `mpsc` command channel + `oneshot` reply; no lock needed on state |
-| Finite state with invalid transition prevention | **Typestate** — distinct types per state; invalid ops are compile errors |
-| Fixed process skeleton with overridable steps | **Template Method** — defaulted trait method calls required hooks |
-| Request pipeline with independent handlers | **Chain/Middleware** — generic compile-time chain for hot paths, `dyn` for runtime assembly |
-| Hiding a concrete type behind a trait | **Factory Function** — returns `Box<dyn Trait>` or `impl Trait` |
-
----
-
-## 4. Data Modeling Rules
-
-- **Make illegal states unrepresentable.** Type system enforces invariants; runtime validation is a second line, not the first.
-- **Newtype every primitive** that carries domain meaning. `SessionId(u64)` ≠ `UserId(u64)` — the compiler enforces it.
-- **Enums over booleans** for any parameter or field with two or more named states.
-- **Typed error enums** with named variants carrying full diagnostic context. `anyhow` is application-layer only; never in library code.
-- **Domain types carry no I/O concerns.** No `serde`, no codec, no DB derives on domain structs. Conversions via `From`/`TryFrom` at layer boundaries.
-
----
-
-## 5. Concurrency Rules
-
-- Prefer message-passing over shared memory. Shared state is a fallback.
-- All channels must be **bounded**. Document the bound's rationale inline.
-- Never hold a lock across an `await` unless atomicity explicitly requires it — document why.
-- Document lock acquisition order wherever two locks are taken together.
-- Every `async fn` is cancellation-safe unless explicitly documented otherwise. Mutate shared state *after* the `await` that may be cancelled, not before.
-- High-read/low-write state: use `arc-swap` or `watch` for lock-free reads.
-
----
-
-## 6. Error Handling Rules
-
-- Errors translated at every layer boundary — low-level errors never surface unmodified.
-- Add context at the propagation site: what operation failed and where.
-- No `unwrap()`/`expect()` in production paths without a comment proving `None`/`Err` is impossible.
-- Panics are only permitted in: tests, startup/init unrecoverable failure, and `unreachable!()` with an invariant comment.
-
----
-
-## 7. API Design Rules
-
-- **CQS**: functions that return data must not mutate; functions that mutate return only `Result`.
-- **Least surprise**: a function does exactly what its name implies. Side effects are documented.
-- **Idempotency**: `close()`, `shutdown()`, `unregister()` called twice must not panic or error.
-- **Fallibility at the type level**: failure → `Result<T, E>`. No sentinel values.
-- **Minimal public surface**: default to `pub(crate)`. Mark `pub` only deliberate API. Re-export through a single surface in `mod.rs`.
-
----
-
-## 8. Performance Rules (hot paths)
-
-- Annotate hot-path functions with `// HOT PATH: <throughput requirement>`.
-- Zero allocations per operation in hot paths after initialization. Preallocate in constructors, reuse buffers.
-- Pass `&[u8]` / `Bytes` slices — not `Vec<u8>`. Use `BytesMut` for reusable mutable buffers.
-- No `String` formatting in hot paths. No logging without a rate-limit or sampling gate.
-- Any allocation in a hot path gets a comment: `// ALLOC: <reason and size>`.
-
----
-
-## 9. Testing Rules
-
-- Bug fixes require a regression test that is **red before the fix, green after**. Name it after the bug.
-- Property tests for: codec round-trips, state machine invariants, cryptographic protocol correctness.
-- No shared mutable state between tests. Each test constructs its own environment.
-- Test doubles hierarchy (simplest first): Fake → Stub → Spy → Mock. Mocks couple to implementation, not behavior — use sparingly.
-
----
-
-## 10. Pre-Change Checklist
-
-Run this before proposing or implementing any structural decision:
-
-- [ ] Responsibility nameable in one noun phrase?
-- [ ] Layer dependencies point inward only?
-- [ ] Invalid states unrepresentable in the type system?
-- [ ] State transitions gated through a single interface?
-- [ ] All channels bounded?
-- [ ] No locks held across `await` (or documented)?
-- [ ] Errors typed and translated at layer boundaries?
-- [ ] No panics in production paths without invariant proof?
-- [ ] Hot paths annotated and allocation-free?
-- [ ] Public surface minimal — only deliberate API marked `pub`?
-- [ ] Correct pattern chosen from Section 3 table?

.github/instructions/rust_rules.instructions.md

@@ -1,135 +0,0 @@
----
-description: 'Rust programming language coding conventions and best practices'
-applyTo: '**/*.rs'
----
-
-# Rust Coding Conventions and Best Practices
-
-Follow idiomatic Rust practices and community standards when writing Rust code. 
-
-These instructions are based on [The Rust Book](https://doc.rust-lang.org/book/), [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/), [RFC 430 naming conventions](https://github.com/rust-lang/rfcs/blob/master/text/0430-finalizing-naming-conventions.md), and the broader Rust community at [users.rust-lang.org](https://users.rust-lang.org).
-
-## General Instructions
-
-- Always prioritize readability, safety, and maintainability.
-- Use strong typing and leverage Rust's ownership system for memory safety.
-- Break down complex functions into smaller, more manageable functions.
-- For algorithm-related code, include explanations of the approach used.
-- Write code with good maintainability practices, including comments on why certain design decisions were made.
-- Handle errors gracefully using `Result<T, E>` and provide meaningful error messages.
-- For external dependencies, mention their usage and purpose in documentation.
-- Use consistent naming conventions following [RFC 430](https://github.com/rust-lang/rfcs/blob/master/text/0430-finalizing-naming-conventions.md).
-- Write idiomatic, safe, and efficient Rust code that follows the borrow checker's rules.
-- Ensure code compiles without warnings.
-
-## Patterns to Follow
-
-- Use modules (`mod`) and public interfaces (`pub`) to encapsulate logic.
-- Handle errors properly using `?`, `match`, or `if let`.
-- Use `serde` for serialization and `thiserror` or `anyhow` for custom errors.
-- Implement traits to abstract services or external dependencies.
-- Structure async code using `async/await` and `tokio` or `async-std`.
-- Prefer enums over flags and states for type safety.
-- Use builders for complex object creation.
-- Split binary and library code (`main.rs` vs `lib.rs`) for testability and reuse.
-- Use `rayon` for data parallelism and CPU-bound tasks.
-- Use iterators instead of index-based loops as they're often faster and safer.
-- Use `&str` instead of `String` for function parameters when you don't need ownership.
-- Prefer borrowing and zero-copy operations to avoid unnecessary allocations.
-
-### Ownership, Borrowing, and Lifetimes
-
-- Prefer borrowing (`&T`) over cloning unless ownership transfer is necessary.
-- Use `&mut T` when you need to modify borrowed data.
-- Explicitly annotate lifetimes when the compiler cannot infer them.
-- Use `Rc<T>` for single-threaded reference counting and `Arc<T>` for thread-safe reference counting.
-- Use `RefCell<T>` for interior mutability in single-threaded contexts and `Mutex<T>` or `RwLock<T>` for multi-threaded contexts.
-
-## Patterns to Avoid
-
-- Don't use `unwrap()` or `expect()` unless absolutely necessary—prefer proper error handling.
-- Avoid panics in library code—return `Result` instead.
-- Don't rely on global mutable state—use dependency injection or thread-safe containers.
-- Avoid deeply nested logic—refactor with functions or combinators.
-- Don't ignore warnings—treat them as errors during CI.
-- Avoid `unsafe` unless required and fully documented.
-- Don't overuse `clone()`, use borrowing instead of cloning unless ownership transfer is needed.
-- Avoid premature `collect()`, keep iterators lazy until you actually need the collection.
-- Avoid unnecessary allocations—prefer borrowing and zero-copy operations.
-
-## Code Style and Formatting
-
-- Follow the Rust Style Guide and use `rustfmt` for automatic formatting.
-- Keep lines under 100 characters when possible.
-- Place function and struct documentation immediately before the item using `///`.
-- Use `cargo clippy` to catch common mistakes and enforce best practices.
-
-## Error Handling
-
-- Use `Result<T, E>` for recoverable errors and `panic!` only for unrecoverable errors.
-- Prefer `?` operator over `unwrap()` or `expect()` for error propagation.
-- Create custom error types using `thiserror` or implement `std::error::Error`.
-- Use `Option<T>` for values that may or may not exist.
-- Provide meaningful error messages and context.
-- Error types should be meaningful and well-behaved (implement standard traits).
-- Validate function arguments and return appropriate errors for invalid input.
-
-## API Design Guidelines
-
-### Common Traits Implementation
-Eagerly implement common traits where appropriate:
-- `Copy`, `Clone`, `Eq`, `PartialEq`, `Ord`, `PartialOrd`, `Hash`, `Debug`, `Display`, `Default`
-- Use standard conversion traits: `From`, `AsRef`, `AsMut`
-- Collections should implement `FromIterator` and `Extend`
-- Note: `Send` and `Sync` are auto-implemented by the compiler when safe; avoid manual implementation unless using `unsafe` code
-
-### Type Safety and Predictability
-- Use newtypes to provide static distinctions
-- Arguments should convey meaning through types; prefer specific types over generic `bool` parameters
-- Use `Option<T>` appropriately for truly optional values
-- Functions with a clear receiver should be methods
-- Only smart pointers should implement `Deref` and `DerefMut`
-
-### Future Proofing
-- Use sealed traits to protect against downstream implementations
-- Structs should have private fields
-- Functions should validate their arguments
-- All public types must implement `Debug`
-
-## Testing and Documentation
-
-- Write comprehensive unit tests using `#[cfg(test)]` modules and `#[test]` annotations.
-- Use test modules alongside the code they test (`mod tests { ... }`).
-- Write integration tests in `tests/` directory with descriptive filenames.
-- Write clear and concise comments for each function, struct, enum, and complex logic.
-- Ensure functions have descriptive names and include comprehensive documentation.
-- Document all public APIs with rustdoc (`///` comments) following the [API Guidelines](https://rust-lang.github.io/api-guidelines/).
-- Use `#[doc(hidden)]` to hide implementation details from public documentation.
-- Document error conditions, panic scenarios, and safety considerations.
-- Examples should use `?` operator, not `unwrap()` or deprecated `try!` macro.
-
-## Project Organization
-
-- Use semantic versioning in `Cargo.toml`.
-- Include comprehensive metadata: `description`, `license`, `repository`, `keywords`, `categories`.
-- Use feature flags for optional functionality.
-- Organize code into modules using `mod.rs` or named files.
-- Keep `main.rs` or `lib.rs` minimal - move logic to modules.
-
-## Quality Checklist
-
-Before publishing or reviewing Rust code, ensure:
-
-### Core Requirements
-- [ ] **Naming**: Follows RFC 430 naming conventions
-- [ ] **Traits**: Implements `Debug`, `Clone`, `PartialEq` where appropriate
-- [ ] **Error Handling**: Uses `Result<T, E>` and provides meaningful error types
-- [ ] **Documentation**: All public items have rustdoc comments with examples
-- [ ] **Testing**: Comprehensive test coverage including edge cases
-
-### Safety and Quality
-- [ ] **Safety**: No unnecessary `unsafe` code, proper error handling
-- [ ] **Performance**: Efficient use of iterators, minimal allocations
-- [ ] **API Design**: Functions are predictable, flexible, and type-safe
-- [ ] **Future Proofing**: Private fields in structs, sealed traits where appropriate
-- [ ] **Tooling**: Code passes `cargo fmt`, `cargo clippy`, and `cargo test`

.github/instructions/self-explanatory-code-commenting.instructions.md

@@ -1,162 +0,0 @@
----
-description: 'Guidelines for GitHub Copilot to write comments to achieve self-explanatory code with less comments. Examples are in JavaScript but it should work on any language that has comments.'
-applyTo: '**'
----
-
-# Self-explanatory Code Commenting Instructions
-
-## Core Principle
-**Write code that speaks for itself. Comment only when necessary to explain WHY, not WHAT.**
-We do not need comments most of the time.
-
-## Commenting Guidelines
-
-### ❌ AVOID These Comment Types
-
-**Obvious Comments**
-```javascript
-// Bad: States the obvious
-let counter = 0;  // Initialize counter to zero
-counter++;  // Increment counter by one
-```
-
-**Redundant Comments**
-```javascript
-// Bad: Comment repeats the code
-function getUserName() {
-    return user.name;  // Return the user's name
-}
-```
-
-**Outdated Comments**
-```javascript
-// Bad: Comment doesn't match the code
-// Calculate tax at 5% rate
-const tax = price * 0.08;  // Actually 8%
-```
-
-### ✅ WRITE These Comment Types
-
-**Complex Business Logic**
-```javascript
-// Good: Explains WHY this specific calculation
-// Apply progressive tax brackets: 10% up to 10k, 20% above
-const tax = calculateProgressiveTax(income, [0.10, 0.20], [10000]);
-```
-
-**Non-obvious Algorithms**
-```javascript
-// Good: Explains the algorithm choice
-// Using Floyd-Warshall for all-pairs shortest paths
-// because we need distances between all nodes
-for (let k = 0; k < vertices; k++) {
-    for (let i = 0; i < vertices; i++) {
-        for (let j = 0; j < vertices; j++) {
-            // ... implementation
-        }
-    }
-}
-```
-
-**Regex Patterns**
-```javascript
-// Good: Explains what the regex matches
-// Match email format: username@domain.extension
-const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-```
-
-**API Constraints or Gotchas**
-```javascript
-// Good: Explains external constraint
-// GitHub API rate limit: 5000 requests/hour for authenticated users
-await rateLimiter.wait();
-const response = await fetch(githubApiUrl);
-```
-
-## Decision Framework
-
-Before writing a comment, ask:
-1. **Is the code self-explanatory?** → No comment needed
-2. **Would a better variable/function name eliminate the need?** → Refactor instead
-3. **Does this explain WHY, not WHAT?** → Good comment
-4. **Will this help future maintainers?** → Good comment
-
-## Special Cases for Comments
-
-### Public APIs
-```javascript
-/**
- * Calculate compound interest using the standard formula.
- * 
- * @param {number} principal - Initial amount invested
- * @param {number} rate - Annual interest rate (as decimal, e.g., 0.05 for 5%)
- * @param {number} time - Time period in years
- * @param {number} compoundFrequency - How many times per year interest compounds (default: 1)
- * @returns {number} Final amount after compound interest
- */
-function calculateCompoundInterest(principal, rate, time, compoundFrequency = 1) {
-    // ... implementation
-}
-```
-
-### Configuration and Constants
-```javascript
-// Good: Explains the source or reasoning
-const MAX_RETRIES = 3;  // Based on network reliability studies
-const API_TIMEOUT = 5000;  // AWS Lambda timeout is 15s, leaving buffer
-```
-
-### Annotations
-```javascript
-// TODO: Replace with proper user authentication after security review
-// FIXME: Memory leak in production - investigate connection pooling
-// HACK: Workaround for bug in library v2.1.0 - remove after upgrade
-// NOTE: This implementation assumes UTC timezone for all calculations
-// WARNING: This function modifies the original array instead of creating a copy
-// PERF: Consider caching this result if called frequently in hot path
-// SECURITY: Validate input to prevent SQL injection before using in query
-// BUG: Edge case failure when array is empty - needs investigation
-// REFACTOR: Extract this logic into separate utility function for reusability
-// DEPRECATED: Use newApiFunction() instead - this will be removed in v3.0
-```
-
-## Anti-Patterns to Avoid
-
-### Dead Code Comments
-```javascript
-// Bad: Don't comment out code
-// const oldFunction = () => { ... };
-const newFunction = () => { ... };
-```
-
-### Changelog Comments
-```javascript
-// Bad: Don't maintain history in comments
-// Modified by John on 2023-01-15
-// Fixed bug reported by Sarah on 2023-02-03
-function processData() {
-    // ... implementation
-}
-```
-
-### Divider Comments
-```javascript
-// Bad: Don't use decorative comments
-//=====================================
-// UTILITY FUNCTIONS
-//=====================================
-```
-
-## Quality Checklist
-
-Before committing, ensure your comments:
-- [ ] Explain WHY, not WHAT
-- [ ] Are grammatically correct and clear
-- [ ] Will remain accurate as code evolves
-- [ ] Add genuine value to code understanding
-- [ ] Are placed appropriately (above the code they describe)
-- [ ] Use proper spelling and professional language
-
-## Summary
-
-Remember: **The best comment is the one you don't need to write because the code is self-documenting.**

.github/workflows/build.yml

@@ -1,39 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [ "*" ]
-  pull_request:
-    branches: [ "*" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install latest stable Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Cache cargo registry & build artifacts
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
-
-      - name: Build Release
-        run: cargo build --release --verbose

.github/workflows/release.yml

@@ -5,87 +5,37 @@ on:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
   workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Release tag (example: 3.3.15)'
-        required: true
-        type: string
-
-concurrency:
-  group: release-${{ github.ref_name }}-${{ github.event.inputs.tag || 'auto' }}
-  cancel-in-progress: true
 
 permissions:
   contents: read
+  packages: write
 
 env:
   CARGO_TERM_COLOR: always
-  BINARY_NAME: telemt
 
 jobs:
-  prepare:
-    name: Prepare
+  build:
+    name: Build ${{ matrix.target }}
     runs-on: ubuntu-latest
-
-    outputs:
-      version: ${{ steps.vars.outputs.version }}
-      prerelease: ${{ steps.vars.outputs.prerelease }}
-
-    steps:
-      - name: Resolve version
-        id: vars
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          if [ "${GITHUB_EVENT_NAME}" = "workflow_dispatch" ]; then
-            VERSION="${{ github.event.inputs.tag }}"
-          else
-            VERSION="${GITHUB_REF#refs/tags/}"
-          fi
-
-          VERSION="${VERSION#refs/tags/}"
-
-          if [ -z "${VERSION}" ]; then
-            echo "Release version is empty" >&2
-            exit 1
-          fi
-
-          if [[ "${VERSION}" == *-* ]]; then
-            PRERELEASE=true
-          else
-            PRERELEASE=false
-          fi
-
-          echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"
-          echo "prerelease=${PRERELEASE}" >> "${GITHUB_OUTPUT}"
-
-  # ==========================
-  # GNU / glibc
-  # ==========================
-  build-gnu:
-    name: GNU ${{ matrix.asset }}
-    runs-on: ubuntu-latest
-    needs: prepare
-
-    container:
-      image: rust:slim-bookworm
+    permissions:
+      contents: read
 
     strategy:
       fail-fast: false
       matrix:
         include:
           - target: x86_64-unknown-linux-gnu
-            asset: telemt-x86_64-linux-gnu
-            cpu: baseline
-
-          - target: x86_64-unknown-linux-gnu
-            asset: telemt-x86_64-v3-linux-gnu
-            cpu: v3
-
+            artifact_name: telemt
+            asset_name: telemt-x86_64-linux-gnu
           - target: aarch64-unknown-linux-gnu
-            asset: telemt-aarch64-linux-gnu
-            cpu: generic
+            artifact_name: telemt
+            asset_name: telemt-aarch64-linux-gnu
+          - target: x86_64-unknown-linux-musl
+            artifact_name: telemt
+            asset_name: telemt-x86_64-linux-musl
+          - target: aarch64-unknown-linux-musl
+            artifact_name: telemt
+            asset_name: telemt-aarch64-linux-musl
 
     steps:
       - uses: actions/checkout@v4
@@ -93,261 +43,47 @@ jobs:
       - uses: dtolnay/rust-toolchain@v1
         with:
           toolchain: stable
-          targets: |
-            x86_64-unknown-linux-gnu
-            aarch64-unknown-linux-gnu
+          targets: ${{ matrix.target }}
 
-      - name: Install deps
+      - name: Install cross-compilation tools
         run: |
-          apt-get update
-          apt-get install -y \
-            build-essential \
-            clang \
-            lld \
-            pkg-config \
-            gcc-aarch64-linux-gnu \
-            g++-aarch64-linux-gnu
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
 
       - uses: actions/cache@v4
         with:
           path: |
-            /usr/local/cargo/registry
-            /usr/local/cargo/git
+            ~/.cargo/registry
+            ~/.cargo/git
             target
-          key: gnu-${{ matrix.asset }}-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-${{ matrix.target }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
-            gnu-${{ matrix.asset }}-
-            gnu-
+            ${{ runner.os }}-${{ matrix.target }}-cargo-
 
-      - name: Build
-        shell: bash
+      - name: Install cross
+        run: cargo install cross --git https://github.com/cross-rs/cross
+
+      - name: Build Release
+        env:
+          RUSTFLAGS: ${{ contains(matrix.target, 'musl') && '-C target-feature=+crt-static' || '' }}
+        run: cross build --release --target ${{ matrix.target }}
+
+      - name: Package binary
         run: |
-          set -euo pipefail
-
-          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-gnu" ]; then
-            export CC=aarch64-linux-gnu-gcc
-            export CXX=aarch64-linux-gnu-g++
-            export RUSTFLAGS="-C linker=aarch64-linux-gnu-gcc -C lto=fat -C panic=abort"
-          else
-            export CC=clang
-            export CXX=clang++
-
-            if [ "${{ matrix.cpu }}" = "v3" ]; then
-              CPU_FLAGS="-C target-cpu=x86-64-v3"
-            else
-              CPU_FLAGS="-C target-cpu=x86-64"
-            fi
-
-            export RUSTFLAGS="-C linker=clang -C link-arg=-fuse-ld=lld -C lto=fat -C panic=abort ${CPU_FLAGS}"
-          fi
-
-          cargo build --release --target ${{ matrix.target }} -j "$(nproc)"
-
-      - name: Package
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          mkdir -p dist
-          cp "target/${{ matrix.target }}/release/${{ env.BINARY_NAME }}" dist/telemt
-
-          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-gnu" ]; then
-            STRIP_BIN=aarch64-linux-gnu-strip
-          else
-            STRIP_BIN=strip
-          fi
-
-          "${STRIP_BIN}" dist/telemt
-
-          cd dist
-          tar -czf "${{ matrix.asset }}.tar.gz" \
-            --owner=0 --group=0 --numeric-owner \
-            telemt
-
-          sha256sum "${{ matrix.asset }}.tar.gz" > "${{ matrix.asset }}.tar.gz.sha256"
+          cd target/${{ matrix.target }}/release
+          tar -czvf ${{ matrix.asset_name }}.tar.gz ${{ matrix.artifact_name }}
+          sha256sum ${{ matrix.asset_name }}.tar.gz > ${{ matrix.asset_name }}.sha256
 
       - uses: actions/upload-artifact@v4
         with:
-          name: ${{ matrix.asset }}
-          path: dist/*
-
-  # ==========================
-  # MUSL
-  # ==========================
-  build-musl:
-    name: MUSL ${{ matrix.asset }}
-    runs-on: ubuntu-latest
-    needs: prepare
-
-    container:
-      image: rust:slim-bookworm
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: x86_64-unknown-linux-musl
-            asset: telemt-x86_64-linux-musl
-            cpu: baseline
-
-          - target: x86_64-unknown-linux-musl
-            asset: telemt-x86_64-v3-linux-musl
-            cpu: v3
-
-          - target: aarch64-unknown-linux-musl
-            asset: telemt-aarch64-linux-musl
-            cpu: generic
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install deps
-        run: |
-          apt-get update
-          apt-get install -y \
-            musl-tools \
-            pkg-config \
-            curl
-
-      - uses: actions/cache@v4
-        if: matrix.target == 'aarch64-unknown-linux-musl'
-        with:
-          path: ~/.musl-aarch64
-          key: musl-toolchain-aarch64-v1
-
-      - name: Install aarch64 musl toolchain
-        if: matrix.target == 'aarch64-unknown-linux-musl'
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TOOLCHAIN_DIR="$HOME/.musl-aarch64"
-          ARCHIVE="aarch64-linux-musl-cross.tgz"
-          URL="https://github.com/telemt/telemt/releases/download/toolchains/${ARCHIVE}"
-
-          if [ -x "${TOOLCHAIN_DIR}/bin/aarch64-linux-musl-gcc" ]; then
-            echo "MUSL toolchain cached"
-          else
-            curl -fL \
-              --retry 5 \
-              --retry-delay 3 \
-              --connect-timeout 10 \
-              --max-time 120 \
-              -o "${ARCHIVE}" "${URL}"
-
-            mkdir -p "${TOOLCHAIN_DIR}"
-            tar -xzf "${ARCHIVE}" --strip-components=1 -C "${TOOLCHAIN_DIR}"
-          fi
-
-          echo "${TOOLCHAIN_DIR}/bin" >> "${GITHUB_PATH}"
-
-      - name: Add rust target
-        run: rustup target add ${{ matrix.target }}
-
-      - uses: actions/cache@v4
-        with:
+          name: ${{ matrix.asset_name }}
           path: |
-            /usr/local/cargo/registry
-            /usr/local/cargo/git
-            target
-          key: musl-${{ matrix.asset }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            musl-${{ matrix.asset }}-
-            musl-
+            target/${{ matrix.target }}/release/${{ matrix.asset_name }}.tar.gz
+            target/${{ matrix.target }}/release/${{ matrix.asset_name }}.sha256
 
-      - name: Build
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-musl" ]; then
-            export CC=aarch64-linux-musl-gcc
-            export CC_aarch64_unknown_linux_musl=aarch64-linux-musl-gcc
-            export RUSTFLAGS="-C target-feature=+crt-static -C linker=aarch64-linux-musl-gcc -C lto=fat -C panic=abort"
-          else
-            export CC=musl-gcc
-            export CC_x86_64_unknown_linux_musl=musl-gcc
-
-            if [ "${{ matrix.cpu }}" = "v3" ]; then
-              CPU_FLAGS="-C target-cpu=x86-64-v3"
-            else
-              CPU_FLAGS="-C target-cpu=x86-64"
-            fi
-
-            export RUSTFLAGS="-C target-feature=+crt-static -C lto=fat -C panic=abort ${CPU_FLAGS}"
-          fi
-
-          cargo build --release --target ${{ matrix.target }} -j "$(nproc)"
-
-      - name: Package
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          mkdir -p dist
-          cp "target/${{ matrix.target }}/release/${{ env.BINARY_NAME }}" dist/telemt
-
-          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-musl" ]; then
-            STRIP_BIN=aarch64-linux-musl-strip
-          else
-            STRIP_BIN=strip
-          fi
-
-          "${STRIP_BIN}" dist/telemt
-
-          cd dist
-          tar -czf "${{ matrix.asset }}.tar.gz" \
-            --owner=0 --group=0 --numeric-owner \
-            telemt
-
-          sha256sum "${{ matrix.asset }}.tar.gz" > "${{ matrix.asset }}.tar.gz.sha256"
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.asset }}
-          path: dist/*
-
-  # ==========================
-  # Release
-  # ==========================
-  release:
-    name: Release
+  build-docker-image:
+    needs: build
     runs-on: ubuntu-latest
-    needs: [prepare, build-gnu, build-musl]
-
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          path: artifacts
-
-      - name: Flatten artifacts
-        shell: bash
-        run: |
-          set -euo pipefail
-          mkdir -p dist
-          find artifacts -type f -exec cp {} dist/ \;
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ needs.prepare.outputs.version }}
-          target_commitish: ${{ github.sha }}
-          files: dist/*
-          generate_release_notes: true
-          prerelease: ${{ needs.prepare.outputs.prerelease == 'true' }}
-          overwrite_files: true
-
-  # ==========================
-  # Docker
-  # ==========================
-  docker:
-    name: Docker
-    runs-on: ubuntu-latest
-    needs: [prepare, release]
-
     permissions:
       contents: read
       packages: write
@@ -356,66 +92,48 @@ jobs:
       - uses: actions/checkout@v4
 
       - uses: docker/setup-qemu-action@v3
-
       - uses: docker/setup-buildx-action@v3
 
-      - uses: docker/login-action@v3
+      - name: Login to GHCR
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Probe release assets
-        shell: bash
-        env:
-          VERSION: ${{ needs.prepare.outputs.version }}
-        run: |
-          set -euo pipefail
+      - name: Extract version
+        id: vars
+        run: echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
 
-          for asset in \
-            telemt-x86_64-linux-musl.tar.gz \
-            telemt-x86_64-linux-musl.tar.gz.sha256 \
-            telemt-aarch64-linux-musl.tar.gz \
-            telemt-aarch64-linux-musl.tar.gz.sha256
-          do
-            curl -fsIL \
-              --retry 10 \
-              --retry-delay 3 \
-              "https://github.com/${GITHUB_REPOSITORY}/releases/download/${VERSION}/${asset}" \
-              > /dev/null
-          done
-
-      - name: Compute image tags
-        id: meta
-        shell: bash
-        env:
-          VERSION: ${{ needs.prepare.outputs.version }}
-        run: |
-          set -euo pipefail
-
-          IMAGE="$(echo "ghcr.io/${GITHUB_REPOSITORY}" | tr '[:upper:]' '[:lower:]')"
-          TAGS="${IMAGE}:${VERSION}"
-
-          if [[ "${VERSION}" != *-* ]]; then
-            TAGS="${TAGS}"$'\n'"${IMAGE}:latest"
-          fi
-
-          {
-            echo "tags<<EOF"
-            printf '%s\n' "${TAGS}"
-            echo "EOF"
-          } >> "${GITHUB_OUTPUT}"
-
-      - name: Build & Push
+      - name: Build and push
         uses: docker/build-push-action@v6
         with:
           context: .
           push: true
-          pull: true
-          platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.meta.outputs.tags }}
-          build-args: |
-            TELEMT_REPOSITORY=${{ github.repository }}
-            TELEMT_VERSION=${{ needs.prepare.outputs.version }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+          tags: |
+            ghcr.io/${{ github.repository }}:${{ steps.vars.outputs.VERSION }}
+            ghcr.io/${{ github.repository }}:latest
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: artifacts/**/*
+          generate_release_notes: true
+          draft: false
+          prerelease: ${{ contains(github.ref, '-rc') || contains(github.ref, '-beta') || contains(github.ref, '-alpha') }}

.github/workflows/rust.yml

@@ -0,0 +1,54 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "*" ]
+  pull_request:
+    branches: [ "*" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      actions: write
+      checks: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Install latest stable Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt, clippy
+
+    - name: Cache cargo registry & build artifacts
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.cargo/registry
+          ~/.cargo/git
+          target
+        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-cargo-
+
+    - name: Build Release
+      run: cargo build --release --verbose
+
+    - name: Run tests
+      run: cargo test --verbose
+
+# clippy dont fail on warnings because of active development of telemt 
+# and many warnings
+    - name: Run clippy
+      run: cargo clippy -- --cap-lints warn
+
+    - name: Check for unused dependencies
+      run: cargo udeps || true

.github/workflows/test.yml

@@ -1,139 +0,0 @@
-name: Check
-
-on:
-  push:
-    branches: [ "*" ]
-  pull_request:
-    branches: [ "*" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-concurrency:
-  group: test-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-# ==========================
-# Formatting
-# ==========================
-  fmt:
-    name: Fmt
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
-
-      - run: cargo fmt -- --check
-
-# ==========================
-# Tests
-# ==========================
-  test:
-    name: Test
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      actions: write
-      checks: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-nextest-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-nextest-
-            ${{ runner.os }}-cargo-
-
-      - name: Install cargo-nextest
-        run: cargo install --locked cargo-nextest || true
-
-      - name: Run tests with nextest
-        run: cargo nextest run -j "$(nproc)"
-
-# ==========================
-# Clippy
-# ==========================
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      checks: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-clippy-
-            ${{ runner.os }}-cargo-
-
-      - name: Run clippy
-        run: cargo clippy -j "$(nproc)" -- --cap-lints warn
-
-# ==========================
-# Udeps
-# ==========================
-  udeps:
-    name: Udeps
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rust-src
-
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-udeps-
-            ${{ runner.os }}-cargo-
-
-      - name: Install cargo-udeps
-        run: cargo install --locked cargo-udeps || true
-
-      - name: Run udeps
-        run: cargo udeps -j "$(nproc)" || true

.gitignore

@@ -21,4 +21,3 @@ target
 #.idea/
 
 proxy-secret
-coverage-html/

.kilocode/rules-architect/AGENTS.md

@@ -0,0 +1,58 @@
+# Architect Mode Rules for Telemt
+
+## Architecture Overview
+
+```mermaid
+graph TB
+    subgraph Entry
+        Client[Clients] --> Listener[TCP/Unix Listener]
+    end
+    
+    subgraph Proxy Layer
+        Listener --> ClientHandler[ClientHandler]
+        ClientHandler --> Handshake[Handshake Validator]
+        Handshake --> |Valid| Relay[Relay Layer]
+        Handshake --> |Invalid| Masking[Masking/TLS Fronting]
+    end
+    
+    subgraph Transport
+        Relay --> MiddleProxy[Middle-End Proxy Pool]
+        Relay --> DirectRelay[Direct DC Relay]
+        MiddleProxy --> TelegramDC[Telegram DCs]
+        DirectRelay --> TelegramDC
+    end
+```
+
+## Module Dependencies
+- [`src/main.rs`](src/main.rs) - Entry point, spawns all async tasks
+- [`src/config/`](src/config/) - Configuration loading with auto-migration
+- [`src/error.rs`](src/error.rs) - Error types, must be used by all modules
+- [`src/crypto/`](src/crypto/) - AES, SHA, random number generation
+- [`src/protocol/`](src/protocol/) - MTProto constants, frame encoding, obfuscation
+- [`src/stream/`](src/stream/) - Stream wrappers, buffer pool, frame codecs
+- [`src/proxy/`](src/proxy/) - Client handling, handshake, relay logic
+- [`src/transport/`](src/transport/) - Upstream management, middle-proxy, SOCKS support
+- [`src/stats/`](src/stats/) - Statistics and replay protection
+- [`src/ip_tracker.rs`](src/ip_tracker.rs) - Per-user IP tracking
+
+## Key Architectural Constraints
+
+### Middle-End Proxy Mode
+- Requires public IP on interface OR 1:1 NAT with STUN probing
+- Uses separate `proxy-secret` from Telegram (NOT user secrets)
+- Falls back to direct mode automatically on STUN mismatch
+
+### TLS Fronting
+- Invalid handshakes are transparently proxied to `mask_host`
+- This is critical for DPI evasion - do not change this behavior
+- `mask_unix_sock` and `mask_host` are mutually exclusive
+
+### Stream Architecture
+- Buffer pool is shared globally via Arc - prevents allocation storms
+- Frame codecs implement tokio-util Encoder/Decoder traits
+- State machine in [`src/stream/state.rs`](src/stream/state.rs) manages stream transitions
+
+### Configuration Migration
+- [`ProxyConfig::load()`](src/config/mod.rs:641) mutates config in-place
+- New fields must have sensible defaults
+- DC203 override is auto-injected for CDN/media support

.kilocode/rules-code/AGENTS.md

@@ -0,0 +1,23 @@
+# Code Mode Rules for Telemt
+
+## Error Handling
+- Always use [`ProxyError`](src/error.rs:168) from [`src/error.rs`](src/error.rs) for proxy operations
+- [`HandshakeResult<T,R,W>`](src/error.rs:292) returns streams on bad client - these MUST be returned for masking, never dropped
+- Use [`Recoverable`](src/error.rs:110) trait to check if errors are retryable
+
+## Configuration Changes
+- [`ProxyConfig::load()`](src/config/mod.rs:641) auto-mutates config - new fields should have defaults
+- DC203 override is auto-injected if missing - do not remove this behavior
+- When adding config fields, add migration logic in [`ProxyConfig::load()`](src/config/mod.rs:641)
+
+## Crypto Code
+- [`SecureRandom`](src/crypto/random.rs) from [`src/crypto/random.rs`](src/crypto/random.rs) must be used for all crypto operations
+- Never use `rand::thread_rng()` directly - use the shared `Arc<SecureRandom>`
+
+## Stream Handling
+- Buffer pool [`BufferPool`](src/stream/buffer_pool.rs) is shared via Arc - always use it instead of allocating
+- Frame codecs in [`src/stream/frame_codec.rs`](src/stream/frame_codec.rs) implement tokio-util's Encoder/Decoder traits
+
+## Testing
+- Tests are inline in modules using `#[cfg(test)]`
+- Use `cargo test --lib <module_name>` to run tests for specific modules

.kilocode/rules-debug/AGENTS.md

@@ -0,0 +1,27 @@
+# Debug Mode Rules for Telemt
+
+## Logging
+- `RUST_LOG` environment variable takes absolute priority over all config log levels
+- Log levels: `trace`, `debug`, `info`, `warn`, `error`
+- Use `RUST_LOG=debug cargo run` for detailed operational logs
+- Use `RUST_LOG=trace cargo run` for full protocol-level debugging
+
+## Middle-End Proxy Debugging
+- Set `ME_DIAG=1` environment variable for high-precision cryptography diagnostics
+- STUN probe results are logged at startup - check for mismatch between local and reflected IP
+- If Middle-End fails, check `proxy_secret_path` points to valid file from https://core.telegram.org/getProxySecret
+
+## Connection Issues
+- DC connectivity is logged at startup with RTT measurements
+- If DC ping fails, check `dc_overrides` for custom addresses
+- Use `prefer_ipv6=false` in config if IPv6 is unreliable
+
+## TLS Fronting Issues
+- Invalid handshakes are proxied to `mask_host` - check this host is reachable
+- `mask_unix_sock` and `mask_host` are mutually exclusive - only one can be set
+- If `mask_unix_sock` is set, socket must exist before connections arrive
+
+## Common Errors
+- `ReplayAttack` - client replayed a handshake nonce, potential attack
+- `TimeSkew` - client clock is off, can disable with `ignore_time_skew=true`
+- `TgHandshakeTimeout` - upstream DC connection failed, check network

AGENTS.md

@@ -5,22 +5,6 @@ Your responses are precise, minimal, and architecturally sound. You are working
 
 ---
 
-### Context: The Telemt Project
-
-You are working on **Telemt**, a high-performance, production-grade Telegram MTProxy implementation written in Rust. It is explicitly designed to operate in highly hostile network environments and evade advanced network censorship.
-
-**Adversarial Threat Model:**
-The proxy operates under constant surveillance by DPI (Deep Packet Inspection) systems and active scanners (state firewalls, mobile operator fraud controls). These entities actively probe IPs, analyze protocol handshakes, and look for known proxy signatures to block or throttle traffic.
-
-**Core Architectural Pillars:**
-1. **TLS-Fronting (TLS-F) & TCP-Splitting (TCP-S):** To the outside world, Telemt looks like a standard TLS server. If a client presents a valid MTProxy key, the connection is handled internally. If a censor's scanner, web browser, or unauthorized crawler connects, Telemt seamlessly splices the TCP connection (L4) to a real, legitimate HTTPS fallback server (e.g., Nginx) without modifying the `ClientHello` or terminating the TLS handshake.
-2. **Middle-End (ME) Orchestration:** A highly concurrent, generation-based pool managing upstream connections to Telegram Datacenters (DCs). It utilizes an **Adaptive Floor** (dynamically scaling writer connections based on traffic), **Hardswaps** (zero-downtime pool reconfiguration), and **STUN/NAT** reflection mechanisms. 
-3. **Strict KDF Routing:** Cryptographic Key Derivation Functions (KDF) in this protocol strictly rely on the exact pairing of Source IP/Port and Destination IP/Port. Deviations or missing port logic will silently break the MTProto handshake.
-4. **Data Plane vs. Control Plane Isolation:** The Data Plane (readers, writers, payload relay, TCP splicing) must remain strictly non-blocking, zero-allocation in hot paths, and highly resilient to network backpressure. The Control Plane (API, metrics, pool generation swaps, config reloads) orchestrates the state asynchronously without stalling the Data Plane.
-
-Any modification you make must preserve Telemt's invisibility to censors, its strict memory-safety invariants, and its hot-path throughput.
-
-
 ### 0. Priority Resolution — Scope Control
 
 This section resolves conflicts between code quality enforcement and scope limitation.
@@ -390,12 +374,6 @@ you MUST explain why existing invariants remain valid.
 - Do not modify existing tests unless the task explicitly requires it.
 - Do not weaken assertions.
 - Preserve determinism in testable components.
-- Bug-first forces the discipline of proving you understand a bug before you fix it. Tests written after a fix almost always pass trivially and catch nothing new.
-- Invariants over scenarios is the core shift. The route_mode table alone would have caught both BUG-1 and BUG-2 before they were written — "snapshot equals watch state after any transition burst" is a two-line property test that fails immediately on the current diverged-atomics code.
-- Differential/model catches logic drift over time.
-- Scheduler pressure is specifically aimed at the concurrent state bugs that keep reappearing. A single-threaded happy-path test of set_mode will never find subtle bugs; 10,000 concurrent calls will find it on the first run.
-- Mutation gate answers your original complaint directly. It measures test power. If you can remove a bounds check and nothing breaks, the suite isn't covering that branch yet — it just says so explicitly.
-- Dead parameter is a code smell rule. 
 
 ### 15. Security Constraints
 

CODE_OF_CONDUCT.md

@@ -1,212 +0,0 @@
-# Code of Conduct
-
-## Purpose
-
-**Telemt exists to solve technical problems.**
-
-Telemt is open to contributors who want to learn, improve and build meaningful systems together.
-
-It is a place for building, testing, reasoning, documenting, and improving systems.
-
-Discussions that advance this work are in scope. Discussions that divert it are not.
-
-Technology has consequences. Responsibility is inherent.
-
-> **Zweck bestimmt die Form.**
-
-> Purpose defines form.
-
----
-
-## Principles
-
-* **Technical over emotional**
-
-  Arguments are grounded in data, logs, reproducible cases, or clear reasoning.
-
-* **Clarity over noise**
-
-  Communication is structured, concise, and relevant.
-
-* **Openness with standards**
-
-  Participation is open. The work remains disciplined.
-
-* **Independence of judgment**
-
-  Claims are evaluated on technical merit, not affiliation or posture.
-
-* **Responsibility over capability**
-
-  Capability does not justify careless use.
-
-* **Cooperation over friction**
-
-  Progress depends on coordination, mutual support, and honest review.
-
-* **Good intent, rigorous method**
-
-  Assume good intent, but require rigor.
-
-> **Aussagen gelten nach ihrer Begründung.**
-
-> Claims are weighed by evidence.
-
----
-
-## Expected Behavior
-
-Participants are expected to:
-
-* Communicate directly and respectfully
-* Support claims with evidence
-* Stay within technical scope
-* Accept critique and provide it constructively
-* Reduce noise, duplication, and ambiguity
-* Help others reach correct and reproducible outcomes
-* Act in a way that improves the system as a whole
-
-Precision is learned.
-
-New contributors are welcome. They are expected to grow into these standards. Existing contributors are expected to make that growth possible.
-
-> **Wer behauptet, belegt.**
-
-> Whoever claims, proves.
-
----
-
-## Unacceptable Behavior
-
-The following is not allowed:
-
-* Personal attacks, insults, harassment, or intimidation
-* Repeatedly derailing discussion away from Telemt’s purpose
-* Spam, flooding, or repeated low-quality input
-* Misinformation presented as fact
-* Attempts to degrade, destabilize, or exhaust Telemt or its participants
-* Use of Telemt or its spaces to enable harm
-
-Telemt is not a venue for disputes that displace technical work.
-Such discussions may be closed, removed, or redirected.
-
-> **Störung ist kein Beitrag.**
-
-> Disruption is not contribution.
-
----
-
-## Security and Misuse
-
-Telemt is intended for responsible use.
-
-* Do not use it to plan, coordinate, or execute harm
-* Do not publish vulnerabilities without responsible disclosure
-* Report security issues privately where possible
-
-Security is both technical and behavioral.
-
-> **Verantwortung endet nicht am Code.**
-
-> Responsibility does not end at the code.
-
----
-
-## 6. Openness
-
-Telemt is open to contributors of different backgrounds, experience levels, and working styles.
-
-- Standards are public, legible, and applied to the work itself.
-- Questions are welcome. Careful disagreement is welcome. Honest correction is welcome.
-- Gatekeeping by obscurity, status signaling, or hostility is not.
-
----
-
-## Scope
-
-This Code of Conduct applies to all official spaces:
-
-* Source repositories (issues, pull requests, discussions)
-* Documentation
-* Communication channels associated with Telemt
-
----
-
-## Maintainer Stewardship
-
-Maintainers are responsible for final decisions in matters of conduct, scope, and direction.
-
-This responsibility is stewardship: 
-- preserving continuity, 
-- protecting signal, 
-- maintaining standards, 
-- keeping Telemt workable for others.
-
-Judgment should be exercised with restraint, consistency, and institutional responsibility.
-- Not every decision requires extended debate.
-- Not every intervention requires public explanation.
-
-All decisions are expected to serve the durability, clarity, and integrity of Telemt.
-
-> **Ordnung ist Voraussetzung der Funktion.**
-
-> Order is the precondition of function.
-
----
-
-## Enforcement
-
-Maintainers may act to preserve the integrity of Telemt, including by:
-
-* Removing content
-* Locking discussions
-* Rejecting contributions
-* Restricting or banning participants
-
-Actions are taken to maintain function, continuity, and signal quality.
-- Where possible, correction is preferred to exclusion.
-- Where necessary, exclusion is preferred to decay.
-
----
-
-## Final
-
-Telemt is built on discipline, structure, and shared intent.
-- Signal over noise.
-- Facts over opinion.
-- Systems over rhetoric.
-
-- Work is collective.
-- Outcomes are shared.
-- Responsibility is distributed.
-
-- Precision is learned.
-- Rigor is expected.
-- Help is part of the work.
-
-> **Ordnung ist Voraussetzung der Freiheit.**
-
-- If you contribute — contribute with care.
-- If you speak — speak with substance.
-- If you engage — engage constructively.
-
----
-
-## After All
-
-Systems outlive intentions.
-- What is built will be used.
-- What is released will propagate.
-- What is maintained will define the future state.
-
-There is no neutral infrastructure, only infrastructure shaped well or poorly.
-
-> **Jedes System trägt Verantwortung.**
-
-> Every system carries responsibility.
-
-- Stability requires discipline.
-- Freedom requires structure.
-- Trust requires honesty.
-
-In the end: the system reflects its contributors.

CONTRIBUTING.md

@@ -1,82 +1,19 @@
-# Issues
-## Warnung
-Before opening Issue, if it is more question than problem or bug - ask about that [in our chat](https://t.me/telemtrs)
-
+# Issues - Rules
 ## What it is not
 - NOT Question and Answer
 - NOT Helpdesk
 
-***Each of your Issues triggers attempts to reproduce problems and analyze them, which are done manually by people***
-
----
-
-# Pull Requests
-
+# Pull Requests - Rules
 ## General
 - ONLY signed and verified commits
 - ONLY from your name
-- DO NOT commit with `codex`, `claude`, or other AI tools as author/committer
+- DO NOT commit with `codex` or `claude` as author/commiter
 - PREFER `flow` branch for development, not `main`
 
----
+## AI
+We are not against modern tools, like AI, where you act as a principal or architect, but we consider it important:
 
-## Definition of Ready (MANDATORY)
-
-A Pull Request WILL be ignored or closed if:
-
-- it does NOT build
-- it does NOT pass tests
-- it does NOT follow formatting rules
-- it contains unrelated or excessive changes
-- the author cannot clearly explain the change
-
----
-
-## Blessed Principles
-- PR must build
-- PR must pass tests
-- PR must be understood by author
-
----
-
-## AI Usage Policy
-
-AI tools (Claude, ChatGPT, Codex, DeepSeek, etc.) are allowed as **assistants**, NOT as decision-makers.
-
-By submitting a PR, you confirm that:
-
-- you fully understand the code you submit
-- you verified correctness manually
-- you reviewed architecture and dependencies
-- you take full responsibility for the change
-
-AI-generated code is treated as **draft** and must be validated like any other external contribution.
-
-PRs that look like unverified AI dumps WILL be closed
-
----
-
-## Maintainer Policy
-
-Maintainers reserve the right to:
-
-- close PRs that do not meet basic quality requirements
-- request explanations before review
-- ignore low-effort contributions
-
-Respect the reviewers time
-
----
-
-## Enforcement
-
-Pull Requests that violate project standards may be closed without review.
-
-This includes (but is not limited to):
-
-- non-building code
-- failing tests
-- unverified or low-effort changes
-- inability to explain the change
-
-These actions follow the Code of Conduct and are intended to preserve signal, quality, and Telemt's integrity
+- you really understand what you're doing
+- you understand the relationships and dependencies of the components being modified
+- you understand the architecture of Telegram MTProto, MTProxy, Middle-End KDF at least generically
+- you DO NOT commit for the sake of commits, but to help the community, core-developers and ordinary users

Cargo.toml

@@ -1,11 +1,8 @@
 [package]
 name = "telemt"
-version = "3.3.38"
+version = "3.3.13"
 edition = "2024"
 
-[features]
-redteam_offline_expected_fail = []
-
 [dependencies]
 # C
 libc = "0.2"
@@ -25,37 +22,26 @@ hmac = "0.12"
 crc32fast = "1.4"
 crc32c = "0.6"
 zeroize = { version = "1.8", features = ["derive"] }
-subtle = "2.6"
-static_assertions = "1.1"
 
 # Network
-socket2 = { version = "0.6", features = ["all"] }
-nix = { version = "0.31", default-features = false, features = [
-  "net",
-  "user",
-  "process",
-  "fs",
-  "signal",
-] }
-shadowsocks = { version = "1.24", features = ["aead-cipher-2022"] }
+socket2 = { version = "0.5", features = ["all"] }
+nix = { version = "0.28", default-features = false, features = ["net"] }
 
 # Serialization
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-toml = "1.0"
-x509-parser = "0.18"
+toml = "0.8"
+x509-parser = "0.15"
 
 # Utils
 bytes = "1.9"
 thiserror = "2.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-tracing-appender = "0.2"
 parking_lot = "0.12"
-dashmap = "6.1"
-arc-swap = "1.7"
+dashmap = "5.5"
 lru = "0.16"
-rand = "0.10"
+rand = "0.9"
 chrono = { version = "0.4", features = ["serde"] }
 hex = "0.4"
 base64 = "0.22"
@@ -64,38 +50,26 @@ regex = "1.11"
 crossbeam-queue = "0.3"
 num-bigint = "0.4"
 num-traits = "0.2"
-x25519-dalek = "2"
 anyhow = "1.0"
 
 # HTTP
-reqwest = { version = "0.13", features = ["rustls"], default-features = false }
-notify = "8.2"
-ipnetwork = { version = "0.21", features = ["serde"] }
+reqwest = { version = "0.12", features = ["rustls-tls"], default-features = false }
+notify = { version = "6", features = ["macos_fsevent"] }
+ipnetwork = "0.20"
 hyper = { version = "1", features = ["server", "http1"] }
 hyper-util = { version = "0.1", features = ["tokio", "server-auto"] }
 http-body-util = "0.1"
 httpdate = "1.0"
-tokio-rustls = { version = "0.26", default-features = false, features = [
-  "tls12",
-] }
-rustls = { version = "0.23", default-features = false, features = [
-  "std",
-  "tls12",
-  "ring",
-] }
-webpki-roots = "1.0"
+tokio-rustls = { version = "0.26", default-features = false, features = ["tls12"] }
+rustls = { version = "0.23", default-features = false, features = ["std", "tls12", "ring"] }
+webpki-roots = "0.26"
 
 [dev-dependencies]
 tokio-test = "0.4"
-criterion = "0.8"
+criterion = "0.5"
 proptest = "1.4"
 futures = "0.3"
 
 [[bench]]
 name = "crypto_bench"
 harness = false
-
-[profile.release]
-lto = "fat"
-codegen-units = 1
-

Dockerfile

@@ -1,98 +1,43 @@
-# syntax=docker/dockerfile:1
+# ==========================
+# Stage 1: Build
+# ==========================
+FROM rust:1.88-slim-bookworm AS builder
 
-ARG TELEMT_REPOSITORY=telemt/telemt
-ARG TELEMT_VERSION=latest
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build
+
+COPY Cargo.toml Cargo.lock* ./
+RUN mkdir src && echo 'fn main() {}' > src/main.rs && \
+    cargo build --release 2>/dev/null || true && \
+    rm -rf src
+
+COPY . .
+RUN cargo build --release && strip target/release/telemt
 
 # ==========================
-# Minimal Image
+# Stage 2: Runtime
 # ==========================
-FROM debian:12-slim AS minimal
+FROM debian:bookworm-slim
 
-ARG TARGETARCH
-ARG TELEMT_REPOSITORY
-ARG TELEMT_VERSION
-
-RUN set -eux; \
-    apt-get update; \
-    apt-get install -y --no-install-recommends \
-        binutils \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
-        curl \
-        tar; \
-    rm -rf /var/lib/apt/lists/*
+    && rm -rf /var/lib/apt/lists/*
 
-RUN set -eux; \
-    case "${TARGETARCH}" in \
-        amd64) ASSET="telemt-x86_64-linux-musl.tar.gz" ;; \
-        arm64) ASSET="telemt-aarch64-linux-musl.tar.gz" ;; \
-        *) echo "Unsupported TARGETARCH: ${TARGETARCH}" >&2; exit 1 ;; \
-    esac; \
-    VERSION="${TELEMT_VERSION#refs/tags/}"; \
-    if [ -z "${VERSION}" ] || [ "${VERSION}" = "latest" ]; then \
-        BASE_URL="https://github.com/${TELEMT_REPOSITORY}/releases/latest/download"; \
-    else \
-        BASE_URL="https://github.com/${TELEMT_REPOSITORY}/releases/download/${VERSION}"; \
-    fi; \
-    curl -fL \
-        --retry 5 \
-        --retry-delay 3 \
-        --connect-timeout 10 \
-        --max-time 120 \
-        -o "/tmp/${ASSET}" \
-        "${BASE_URL}/${ASSET}"; \
-    curl -fL \
-        --retry 5 \
-        --retry-delay 3 \
-        --connect-timeout 10 \
-        --max-time 120 \
-        -o "/tmp/${ASSET}.sha256" \
-        "${BASE_URL}/${ASSET}.sha256"; \
-    cd /tmp; \
-    sha256sum -c "${ASSET}.sha256"; \
-    tar -xzf "${ASSET}" -C /tmp; \
-    test -f /tmp/telemt; \
-    install -m 0755 /tmp/telemt /telemt; \
-    strip --strip-unneeded /telemt || true; \
-    rm -f "/tmp/${ASSET}" "/tmp/${ASSET}.sha256" /tmp/telemt
-
-# ==========================
-# Debug Image
-# ==========================
-FROM debian:12-slim AS debug
-
-RUN set -eux; \
-    apt-get update; \
-    apt-get install -y --no-install-recommends \
-        ca-certificates \
-        tzdata \
-        curl \
-        iproute2 \
-        busybox; \
-    rm -rf /var/lib/apt/lists/*
+RUN useradd -r -s /usr/sbin/nologin telemt
 
 WORKDIR /app
 
-COPY --from=minimal /telemt /app/telemt
+COPY --from=builder /build/target/release/telemt /app/telemt
 COPY config.toml /app/config.toml
 
-EXPOSE 443 9090 9091
-
-ENTRYPOINT ["/app/telemt"]
-CMD ["config.toml"]
-
-# ==========================
-# Production Distroless on MUSL
-# ==========================
-FROM gcr.io/distroless/static-debian12 AS prod
-
-WORKDIR /app
-
-COPY --from=minimal /telemt /app/telemt
-COPY config.toml /app/config.toml
-
-USER nonroot:nonroot
-
-EXPOSE 443 9090 9091
+RUN chown -R telemt:telemt /app
+USER telemt
+
+EXPOSE 443
+EXPOSE 9090
 
 ENTRYPOINT ["/app/telemt"]
 CMD ["config.toml"]

LICENSE

@@ -1,169 +0,0 @@
-######## TELEMT LICENSE 3.3 #########
-##### Copyright (c) 2026 Telemt #####
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this Software and associated documentation files (the "Software"),
-to use, reproduce, modify, prepare derivative works of, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, provided that all
-copyright notices, license terms, and conditions set forth in this License
-are preserved and complied with.
-
-### Official Translations
-
-The canonical version of this License is the English version.
-Official translations are provided for informational purposes only
-and for convenience, and do not have legal force. In case of any
-discrepancy, the English version of this License shall prevail
-
-/----------------------------------------------------------\
-| Language    | Location                                   |
-|-------------|--------------------------------------------|
-| English     | docs/LICENSE/TELEMT-LICENSE.en.md          |
-| German      | docs/LICENSE/TELEMT-LICENSE.de.md          |
-| Russian     | docs/LICENSE/TELEMT-LICENSE.ru.md          |
-\----------------------------------------------------------/
-
-### License Versioning Policy
-
-This License is version 3 of the TELEMT Public License.
-Each version of the Software is licensed under the License that
-accompanies its corresponding source code distribution.
-
-Future versions of the Software may be distributed under a different
-version of the TELEMT Public License or under a different license,
-as determined by the Telemt maintainers.
-
-Any such change of license applies only to the versions of the
-Software distributed with the new license and SHALL NOT retroactively
-affect any previously released versions of the Software.
-
-Recipients of the Software are granted rights only under the License
-provided with the version of the Software they received.
-
-Redistributions of the Software, including Modified Versions, MUST
-preserve the copyright notices, license text, and conditions of this
-License for all portions of the Software derived from Telemt.
-
-Additional terms or licenses may be applied to modifications or
-additional code added by a redistributor, provided that such terms
-do not restrict or alter the rights granted under this License for
-the original Telemt Software.
-
-Nothing in this section limits the rights granted under this License
-for versions of the Software already released.
-
-### Definitions
-
-For the purposes of this License:
-- "Software" means the Telemt software, including source code, documentation,
-and any associated files distributed under this License.
-- "Contributor" means any person or entity that submits code, patches,
-documentation, or other contributions to the Software that are accepted
-into the Software by the maintainers.
-- "Contribution" means any work of authorship intentionally submitted
-to the Software for inclusion in the Software.
-- "Modified Version" means any version of the Software that has been
-changed, adapted, extended, or otherwise modified from the original
-Software.
-- "Maintainers" means the individuals or entities responsible for
-the official Telemt project and its releases.
-
-#### 1 Attribution
-
-Redistributions of the Software, in source or binary form, MUST RETAIN the
-above copyright notice, this license text, and any existing attribution
-notices.
-
-#### 2 Modification Notice
-
-If you modify the Software, you MUST clearly state that the Software has been
-modified and include a brief description of the changes made.
-
-Modified versions MUST NOT be presented as the original Telemt.
-
-#### 3 Trademark and Branding
-
-This license DOES NOT grant permission to use the name "Telemt", 
-the Telemt logo, or any Telemt trademarks or branding.
-
-Redistributed or modified versions of the Software MAY NOT use the Telemt
-name in a way that suggests endorsement or official origin without explicit
-permission from the Telemt maintainers.
-
-Use of the name "Telemt" to describe a modified version of the Software
-is permitted only if the modified version is clearly identified as a
-modified or unofficial version.
-
-Any distribution that could reasonably confuse users into believing that
-the software is an official Telemt release is prohibited.
-
-#### 4 Binary Distribution Transparency
-
-If you distribute compiled binaries of the Software,
-you are ENCOURAGED to provide access to the corresponding
-source code and build instructions where reasonably possible.
-
-This helps preserve transparency and allows recipients to verify the
-integrity and reproducibility of distributed builds.
-
-#### 5 Patent Grant and Defensive Termination Clause
-
-Each contributor grants you a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable patent license to make, have made,
-use, offer to sell, sell, import, and otherwise transfer the Software.
-
-This patent license applies only to those patent claims necessarily
-infringed by the contributor’s contribution alone or by combination of
-their contribution with the Software.
-
-If you initiate or participate in any patent litigation, including
-cross-claims or counterclaims, alleging that the Software or any
-contribution incorporated within the Software constitutes patent
-infringement, then **all rights granted to you under this license shall
-terminate immediately** as of the date such litigation is filed.
-
-Additionally, if you initiate legal action alleging that the
-Software itself infringes your patent or other intellectual
-property rights, then all rights granted to you under this
-license SHALL TERMINATE automatically.
-
-#### 6 Contributions
-
-Unless you explicitly state otherwise, any Contribution intentionally
-submitted for inclusion in the Software shall be licensed under the terms
-of this License.
-
-By submitting a Contribution, you grant the Telemt maintainers and all
-recipients of the Software the rights described in this License with
-respect to that Contribution.
-
-#### 7 Network Use Attribution
-
-If the Software is used to provide a publicly accessible network service,
-the operator of such service SHOULD provide attribution to Telemt in at least
-one of the following locations:
-
-- service documentation
-- service description
-- an "About" or similar informational page
-- other user-visible materials reasonably associated with the service
-
-Such attribution MUST NOT imply endorsement by the Telemt project or its
-maintainers.
-
-#### 8 Disclaimer of Warranty and Severability Clause
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-USE OR OTHER DEALINGS IN THE SOFTWARE
-
-IF ANY PROVISION OF THIS LICENSE IS HELD TO BE INVALID OR UNENFORCEABLE,
-SUCH PROVISION SHALL BE INTERPRETED TO REFLECT THE ORIGINAL INTENT
-OF THE PARTIES AS CLOSELY AS POSSIBLE, AND THE REMAINING PROVISIONS
-SHALL REMAIN IN FULL FORCE AND EFFECT

LICENSING.md

@@ -1,12 +1,17 @@
 # LICENSING
 ## Licenses for Versions
-| Version ≥ | Version ≤ | License       |
-|-----------|-----------|---------------|
-| 1.0       | 3.3.17    | NO LICNESE    |
-| 3.3.18    | 3.4.0     | TELEMT PL 3   |
+| Version | License       |
+|---------|---------------|
+| 1.0     | NO LICNESE    |
+| 1.1     | NO LICENSE    |
+| 1.2     | NO LICENSE    |
+| 2.0     | NO LICENSE    |
+| 3.0     | TELEMT UL 1   |
 
 ### License Types
 - **NO LICENSE** = ***ALL RIGHT RESERVED***
-- **TELEMT PL** - special Telemt Public License based on Apache License 2 principles
-
-## [Telemt Public License 3](https://github.com/telemt/telemt/blob/main/LICENSE)
+- **TELEMT UL1** - work in progress license for source code of `telemt`, which encourages:
+  - fair use, 
+  - contributions, 
+  - distribution, 
+  - but prohibits NOT mentioning the authors

README.md

@@ -2,11 +2,6 @@
 
 ***Löst Probleme, bevor andere überhaupt wissen, dass sie existieren*** / ***It solves problems before others even realize they exist***
 
-### [**Telemt Chat in Telegram**](https://t.me/telemtrs)
-#### Fixed TLS ClientHello is now available in Telegram Desktop starting from version 6.7.2: to work with EE-MTProxy, please update your client;
-#### Fixed TLS ClientHello for Telegram Android Client is available in [our chat](https://t.me/telemtrs/30234/36441); official releases for Android and iOS are "work in progress";
-
-
 **Telemt** is a fast, secure, and feature-rich server written in Rust: it fully implements the official Telegram proxy algo and adds many production-ready improvements such as:
 - [ME Pool + Reader/Writer + Registry + Refill + Adaptive Floor + Trio-State + Generation Lifecycle](https://github.com/telemt/telemt/blob/main/docs/model/MODEL.en.md)
 - [Full-covered API w/ management](https://github.com/telemt/telemt/blob/main/docs/API.md)
@@ -14,6 +9,86 @@
 - Prometheus-format Metrics
 - TLS-Fronting and TCP-Splicing for masking from "prying" eyes
 
+[**Telemt Chat in Telegram**](https://t.me/telemtrs)
+
+## NEWS and EMERGENCY
+### ✈️ Telemt 3 is released!
+<table>
+<tr>
+<td width="50%" valign="top">
+
+### 🇷🇺 RU
+
+#### Релиз 3.3.5 LTS - 6 марта
+
+6 марта мы выпустили Telemt **3.3.5**
+
+Это [3.3.5 - первая LTS-версия telemt](https://github.com/telemt/telemt/releases/tag/3.3.5)!
+
+В ней используется:
+- новый алгоритм ME NoWait для непревзойдённо быстрого восстановления пула
+- Adaptive Floor, поддерживающий количество ME Writer на оптимальном уровне
+- модель усовершенствованного доступа к KDF Fingerprint на RwLock
+- строгая привязка Middle-End к DC-ID с предсказуемым алгоритмом деградации и самовосстановления
+
+Telemt Control API V1 в 3.3.5 включает:
+- несколько режимов работы в зависимости от доступных ресурсов
+- снапшот-модель для живых метрик без вмешательства в hot-path
+- минималистичный набор запросов для управления пользователями
+
+Будем рады вашему фидбеку и предложениям по улучшению — особенно в части **API**, **статистики**, **UX**
+
+---
+
+Если у вас есть компетенции в:
+
+- Асинхронных сетевых приложениях  
+- Анализе трафика  
+- Реверс-инжиниринге  
+- Сетевых расследованиях  
+
+Мы открыты к архитектурным предложениям, идеям и pull requests
+</td>
+<td width="50%" valign="top">
+
+### 🇬🇧 EN
+
+#### Release 3.3.5 LTS - March 6
+
+On March 6, we released Telemt **3.3.3**
+
+This is [3.3.5 - the first LTS release of telemt](https://github.com/telemt/telemt/releases/tag/3.3.5)
+
+It introduces:
+- the new ME NoWait algorithm for exceptionally fast pool recovery
+- Adaptive Floor, which maintains the number of ME Writers at an optimal level
+- an improved KDF Fingerprint access model based on RwLock
+- strict binding of Middle-End instances to DC-ID with a predictable degradation and self-recovery algorithm
+
+Telemt Control API V1 in version 3.3.5 includes:
+- multiple operating modes depending on available resources
+- a snapshot-based model for live metrics without interfering with the hot path
+- a minimalistic request set for user management
+
+We are looking forward to your feedback and improvement proposals — especially regarding **API**, **statistics**, **UX**
+
+---
+
+If you have expertise in:
+
+- Asynchronous network applications  
+- Traffic analysis  
+- Reverse engineering  
+- Network forensics  
+
+We welcome ideas, architectural feedback, and pull requests.
+</td>
+</tr>
+</table>
+
+# Features
+💥 The configuration structure has changed since version 1.1.0.0. change it in your environment!
+
 ⚓ Our implementation of **TLS-fronting** is one of the most deeply debugged, focused, advanced and *almost* **"behaviorally consistent to real"**:  we are confident we have it right - [see evidence on our validation and traces](#recognizability-for-dpi-and-crawler)
 
 ⚓ Our ***Middle-End Pool*** is fastest by design in standard scenarios, compared to other implementations of connecting to the Middle-End Proxy: non dramatically, but usual
@@ -29,8 +104,17 @@
 - Extensive logging via `trace` and `debug` with `RUST_LOG` method
 
 # GOTO
-- [Quick Start Guide](#quick-start-guide)
-- [FAQ](#faq)
+- [Telemt - MTProxy on Rust + Tokio](#telemt---mtproxy-on-rust--tokio)
+  - [NEWS and EMERGENCY](#news-and-emergency)
+    - [✈️ Telemt 3 is released!](#️-telemt-3-is-released)
+    - [🇷🇺 RU](#-ru)
+      - [Релиз 3.3.5 LTS - 6 марта](#релиз-335-lts---6-марта)
+    - [🇬🇧 EN](#-en)
+      - [Release 3.3.5 LTS - March 6](#release-335-lts---march-6)
+- [Features](#features)
+- [GOTO](#goto)
+  - [Quick Start Guide](#quick-start-guide)
+  - [FAQ](#faq)
     - [Recognizability for DPI and crawler](#recognizability-for-dpi-and-crawler)
       - [Client WITH secret-key accesses the MTProxy resource:](#client-with-secret-key-accesses-the-mtproxy-resource)
       - [Client WITHOUT secret-key gets transparent access to the specified resource:](#client-without-secret-key-gets-transparent-access-to-the-specified-resource)
@@ -38,10 +122,10 @@
     - [How does DPI see MTProxy TLS?](#how-does-dpi-see-mtproxy-tls)
     - [Whitelist on IP](#whitelist-on-ip)
     - [Too many open files](#too-many-open-files)
-- [Build](#build)
-- [Why Rust?](#why-rust)
-- [Issues](#issues)
-- [Roadmap](#roadmap)
+  - [Build](#build)
+  - [Why Rust?](#why-rust)
+  - [Issues](#issues)
+  - [Roadmap](#roadmap)
 
 
 ## Quick Start Guide
@@ -54,12 +138,8 @@
 - [FAQ EN](docs/FAQ.en.md)
 
 ### Recognizability for DPI and crawler
-
-On April 1, 2026, we became aware of a method for detecting MTProxy Fake-TLS, 
-based on the ECH extension and the ordering of cipher suites, 
-as well as an overall unique JA3/JA4 fingerprint 
-that does not occur in modern browsers: 
-we have already submitted initial changes to the Telegram Desktop developers and are working on updates for other clients.
+Since version 1.1.0.0, we have debugged masking perfectly: for all clients without "presenting" a key, 
+we transparently direct traffic to the target host!
 
 - We consider this a breakthrough aspect, which has no stable analogues today
 - Based on this: if `telemt` configured correctly, **TLS mode is completely identical to real-life handshake + communication** with a specified host
@@ -193,11 +273,6 @@ git clone https://github.com/telemt/telemt
 cd telemt
 # Starting Release Build
 cargo build --release
-
-# Low-RAM devices (1 GB, e.g. NanoPi Neo3 / Raspberry Pi Zero 2):
-# release profile uses lto = "thin" to reduce peak linker memory.
-# If your custom toolchain overrides profiles, avoid enabling fat LTO.
-
 # Move to /bin
 mv ./target/release/telemt /bin
 # Make executable
@@ -206,12 +281,6 @@ chmod +x /bin/telemt
 telemt config.toml
 ```
 
-### OpenBSD
-- Build and service setup guide: [OpenBSD Guide (EN)](docs/OPENBSD.en.md)
-- Example rc.d script: [contrib/openbsd/telemt.rcd](contrib/openbsd/telemt.rcd)
-- Status: OpenBSD sandbox hardening with `pledge(2)` and `unveil(2)` is not implemented yet.
-
-
 ## Why Rust?
 - Long-running reliability and idempotent behavior
 - Rust's deterministic resource management - RAII 

benches/crypto_bench.rs

@@ -1,5 +1,5 @@
 // Cryptobench
-use criterion::{Criterion, black_box, criterion_group};
+use criterion::{black_box, criterion_group, Criterion};
 
 fn bench_aes_ctr(c: &mut Criterion) {
     c.bench_function("aes_ctr_encrypt_64kb", |b| {

config.full.toml

@@ -0,0 +1,697 @@
+# ==============================================================================
+#
+#   TELEMT — Advanced Rust-based Telegram MTProto Proxy
+#   Full Configuration Reference
+#
+#   This file is both a working config and a complete documentation.
+#   Every parameter is explained. Read it top to bottom before deploying.
+#
+#   Quick Start:
+#     1. Set [server].port to your desired port (443 recommended)
+#     2. Generate a secret: openssl rand -hex 16
+#     3. Put it in [access.users] under a name you choose
+#     4. Set [censorship].tls_domain to a popular unblocked HTTPS site
+#     5. Set your public IP in [general].middle_proxy_nat_ip
+#        and [general.links].public_host
+#     6. Set announce IP in [[server.listeners]]
+#     7. Run Telemt. It prints a tg:// link. Send it to your users.
+#
+#   Modes of Operation:
+#     Direct Mode  (use_middle_proxy = false)
+#       Connects straight to Telegram DCs via TCP. Simple, fast, low overhead.
+#       No ad_tag support. No CDN DC support (203, etc).
+#
+#     Middle-Proxy Mode  (use_middle_proxy = true)
+#       Connects to Telegram Middle-End servers via RPC protocol.
+#       Required for ad_tag monetization and CDN support.
+#       Requires proxy_secret_path and a valid public IP.
+#
+# ==============================================================================
+
+
+# ==============================================================================
+# LEGACY TOP-LEVEL FIELDS
+# ==============================================================================
+
+# Deprecated. Use [general.links].show instead.
+# Accepts "*" for all users, or an array like ["alice", "bob"].
+show_link = ["0"]
+
+# Fallback Datacenter index (1-5) when a client requests an unknown DC ID.
+# DC 2 is Amsterdam (Europe), closest for most CIS users.
+# default_dc = 2
+
+
+# ==============================================================================
+# GENERAL SETTINGS
+# ==============================================================================
+
+[general]
+
+# ------------------------------------------------------------------------------
+# Core Protocol
+# ------------------------------------------------------------------------------
+
+# Coalesce the MTProto handshake and first data payload into a single TCP packet.
+# Significantly reduces connection latency. No reason to disable.
+fast_mode = true
+
+# How the proxy connects to Telegram servers.
+# false = Direct TCP to Telegram DCs (simple, low overhead)
+# true  = Middle-End RPC protocol (required for ad_tag and CDN DCs)
+use_middle_proxy = true
+
+# 32-char hex Ad-Tag from @MTProxybot for sponsored channel injection.
+# Only works when use_middle_proxy = true.
+# Obtain yours: message @MTProxybot on Telegram, register your proxy.
+# ad_tag = "00000000000000000000000000000000"
+
+# ------------------------------------------------------------------------------
+# Middle-End Authentication
+# ------------------------------------------------------------------------------
+
+# Path to the Telegram infrastructure AES key file.
+# Auto-downloaded from https://core.telegram.org/getProxySecret on first run.
+# This key authenticates your proxy with Middle-End servers.
+proxy_secret_path = "proxy-secret"
+
+# ------------------------------------------------------------------------------
+# Public IP Configuration (Critical for Middle-Proxy Mode)
+# ------------------------------------------------------------------------------
+
+# Your server's PUBLIC IPv4 address.
+# Middle-End servers need this for the cryptographic Key Derivation Function.
+# If your server has a direct public IP, set it here.
+# If behind NAT (AWS, Docker, etc.), this MUST be your external IP.
+# If omitted, Telemt uses STUN to auto-detect (see middle_proxy_nat_probe).
+# middle_proxy_nat_ip = "203.0.113.10"
+
+# Auto-detect public IP via STUN servers defined in [network].
+# Set to false if you hardcoded middle_proxy_nat_ip above.
+# Set to true if you want automatic detection.
+middle_proxy_nat_probe = true
+
+# ------------------------------------------------------------------------------
+# Middle-End Connection Pool
+# ------------------------------------------------------------------------------
+
+# Number of persistent multiplexed RPC connections to ME servers.
+# All client traffic is routed through these "fat pipes".
+# 8 handles thousands of concurrent users comfortably.
+middle_proxy_pool_size = 8
+
+# Legacy field. Connections kept initialized but idle as warm standby.
+middle_proxy_warm_standby = 16
+
+# ------------------------------------------------------------------------------
+# Middle-End Keepalive
+# Telegram ME servers aggressively kill idle TCP connections.
+# These settings send periodic RPC_PING frames to keep pipes alive.
+# ------------------------------------------------------------------------------
+
+me_keepalive_enabled = true
+
+# Base interval between pings in seconds.
+me_keepalive_interval_secs = 25
+
+# Random jitter added to interval to prevent all connections pinging simultaneously.
+me_keepalive_jitter_secs = 5
+
+# Randomize ping payload bytes to prevent DPI from fingerprinting ping patterns.
+me_keepalive_payload_random = true
+
+# ------------------------------------------------------------------------------
+# Client-Side Limits
+# ------------------------------------------------------------------------------
+
+# Max buffered ciphertext per client (bytes) when upstream is slow.
+# Acts as backpressure to prevent memory exhaustion. 256KB is safe.
+crypto_pending_buffer = 262144
+
+# Maximum single MTProto frame size from client. 16MB is protocol standard.
+max_client_frame = 16777216
+
+# ------------------------------------------------------------------------------
+# Crypto Desynchronization Logging
+# Desync errors usually mean DPI/GFW is tampering with connections.
+# ------------------------------------------------------------------------------
+
+# true  = full forensics (trace ID, IP hash, hex dumps) for EVERY desync event
+# false = deduplicated logging, one entry per time window (prevents log spam)
+# Set true if you are actively debugging DPI interference.
+desync_all_full = true
+
+# ------------------------------------------------------------------------------
+# Beobachten — Built-in Honeypot / Active Probe Tracker
+# Tracks IPs that fail handshakes or behave like TLS scanners.
+# Output file can be fed into fail2ban or iptables for auto-blocking.
+# ------------------------------------------------------------------------------
+
+beobachten = true
+
+# How long (minutes) to remember a suspicious IP before expiring it.
+beobachten_minutes = 30
+
+# How often (seconds) to flush tracker state to disk.
+beobachten_flush_secs = 15
+
+# File path for the tracker output.
+beobachten_file = "cache/beobachten.txt"
+
+# ------------------------------------------------------------------------------
+# Hardswap — Zero-Downtime ME Pool Rotation
+# When Telegram updates ME server IPs, Hardswap creates a completely new pool,
+# waits until it is fully ready, migrates traffic, then kills the old pool.
+# Users experience zero interruption.
+# ------------------------------------------------------------------------------
+
+hardswap = true
+
+# ------------------------------------------------------------------------------
+# ME Pool Warmup Staggering
+# When creating a new pool, connections are opened one by one with delays
+# to avoid a burst of SYN packets that could trigger ISP flood protection.
+# ------------------------------------------------------------------------------
+
+me_warmup_stagger_enabled = true
+
+# Delay between each connection creation (milliseconds).
+me_warmup_step_delay_ms = 500
+
+# Random jitter added to the delay (milliseconds).
+me_warmup_step_jitter_ms = 300
+
+# ------------------------------------------------------------------------------
+# ME Reconnect Backoff
+# If an ME server drops the connection, Telemt retries with this strategy.
+# ------------------------------------------------------------------------------
+
+# Max simultaneous reconnect attempts per DC.
+me_reconnect_max_concurrent_per_dc = 8
+
+# Exponential backoff base (milliseconds).
+me_reconnect_backoff_base_ms = 500
+
+# Backoff ceiling (milliseconds). Will never wait longer than this.
+me_reconnect_backoff_cap_ms = 30000
+
+# Number of instant retries before switching to exponential backoff.
+me_reconnect_fast_retry_count = 12
+
+# ------------------------------------------------------------------------------
+# NAT Mismatch Behavior
+# If STUN-detected IP differs from local interface IP (you are behind NAT).
+# false = abort ME mode (safe default)
+# true  = force ME mode anyway (use if you know your NAT setup is correct)
+# ------------------------------------------------------------------------------
+
+stun_iface_mismatch_ignore = false
+
+# ------------------------------------------------------------------------------
+# Logging
+# ------------------------------------------------------------------------------
+
+# File to log unknown DC requests (DC IDs outside standard 1-5).
+unknown_dc_log_path = "unknown-dc.txt"
+
+# Verbosity: "debug" | "verbose" | "normal" | "silent"
+log_level = "normal"
+
+# Disable ANSI color codes in log output (useful for file logging).
+disable_colors = false
+
+# ------------------------------------------------------------------------------
+# FakeTLS Record Sizing
+# Buffer small MTProto packets into larger TLS records to mimic real HTTPS.
+# Real HTTPS servers send records close to MTU size (~1400 bytes).
+# A stream of tiny TLS records is a strong DPI signal.
+# Set to 0 to disable. Set to 1400 for realistic HTTPS emulation.
+# ------------------------------------------------------------------------------
+
+fast_mode_min_tls_record = 1400
+
+# ------------------------------------------------------------------------------
+# Periodic Updates
+# ------------------------------------------------------------------------------
+
+# How often (seconds) to re-fetch ME server lists and proxy secrets
+# from core.telegram.org. Keeps your proxy in sync with Telegram infrastructure.
+update_every = 300
+
+# How often (seconds) to force a Hardswap even if the ME map is unchanged.
+# Shorter intervals mean shorter-lived TCP flows, harder for DPI to profile.
+me_reinit_every_secs = 600
+
+# ------------------------------------------------------------------------------
+# Hardswap Warmup Tuning
+# Fine-grained control over how the new pool is warmed up before traffic switch.
+# ------------------------------------------------------------------------------
+
+me_hardswap_warmup_delay_min_ms = 1000
+me_hardswap_warmup_delay_max_ms = 2000
+me_hardswap_warmup_extra_passes = 3
+me_hardswap_warmup_pass_backoff_base_ms = 500
+
+# ------------------------------------------------------------------------------
+# Config Update Debouncing
+# Telegram sometimes pushes transient/broken configs. Debouncing requires
+# N consecutive identical fetches before applying a change.
+# ------------------------------------------------------------------------------
+
+# ME server list must be identical for this many fetches before applying.
+me_config_stable_snapshots = 2
+
+# Minimum seconds between config applications.
+me_config_apply_cooldown_secs = 300
+
+# Proxy secret must be identical for this many fetches before applying.
+proxy_secret_stable_snapshots = 2
+
+# ------------------------------------------------------------------------------
+# Proxy Secret Rotation
+# ------------------------------------------------------------------------------
+
+# Apply newly downloaded secrets at runtime without restart.
+proxy_secret_rotate_runtime = true
+
+# Maximum acceptable secret length (bytes). Rejects abnormally large secrets.
+proxy_secret_len_max = 256
+
+# ------------------------------------------------------------------------------
+# Hardswap Drain Settings
+# Controls graceful shutdown of old ME connections during pool rotation.
+# ------------------------------------------------------------------------------
+
+# Seconds to keep old connections alive for in-flight data before force-closing.
+me_pool_drain_ttl_secs = 90
+
+# Minimum ratio of healthy connections in new pool before draining old pool.
+# 0.8 = at least 80% of new pool must be ready.
+me_pool_min_fresh_ratio = 0.8
+
+# Maximum seconds to wait for drain to complete before force-killing.
+me_reinit_drain_timeout_secs = 120
+
+# ------------------------------------------------------------------------------
+# NTP Clock Check
+# MTProto uses timestamps. Clock drift > 30 seconds breaks handshakes.
+# Telemt checks on startup and warns if out of sync.
+# ------------------------------------------------------------------------------
+
+ntp_check = true
+ntp_servers = ["pool.ntp.org"]
+
+# ------------------------------------------------------------------------------
+# Auto-Degradation
+# If ME servers become completely unreachable (ISP blocking),
+# automatically fall back to Direct Mode so users stay connected.
+# ------------------------------------------------------------------------------
+
+auto_degradation_enabled = true
+
+# Number of DC groups that must be unreachable before triggering fallback.
+degradation_min_unavailable_dc_groups = 2
+
+
+# ==============================================================================
+# ALLOWED CLIENT PROTOCOLS
+# Only enable what you need. In censored regions, TLS-only is safest.
+# ==============================================================================
+
+[general.modes]
+
+# Classic MTProto. Unobfuscated length prefixes. Trivially detected by DPI.
+# No reason to enable unless you have ancient clients.
+classic = false
+
+# Obfuscated MTProto with randomized padding. Better than classic, but
+# still detectable by statistical analysis of packet sizes.
+secure = false
+
+# FakeTLS (ee-secrets). Wraps MTProto in TLS 1.3 framing.
+# To DPI, it looks like a normal HTTPS connection.
+# This should be the ONLY enabled mode in censored environments.
+tls = true
+
+
+# ==============================================================================
+# STARTUP LINK GENERATION
+# Controls what tg:// invite links are printed to console on startup.
+# ==============================================================================
+
+[general.links]
+
+# Which users to generate links for.
+# "*" = all users, or an array like ["alice", "bob"].
+show = "*"
+
+# IP or domain to embed in the tg:// link.
+# If omitted, Telemt uses STUN to auto-detect.
+# Set this to your server's public IP or domain for reliable links.
+# public_host = "proxy.example.com"
+
+# Port to embed in the tg:// link.
+# If omitted, uses [server].port.
+# public_port = 443
+
+
+# ==============================================================================
+# NETWORK & IP RESOLUTION
+# ==============================================================================
+
+[network]
+
+# Enable IPv4 for outbound connections to Telegram.
+ipv4 = true
+
+# Enable IPv6 for outbound connections to Telegram.
+ipv6 = false
+
+# Prefer IPv4 (4) or IPv6 (6) when both are available.
+prefer = 4
+
+# Experimental: use both IPv4 and IPv6 ME servers simultaneously.
+# May improve reliability but doubles connection count.
+multipath = false
+
+# STUN servers for external IP discovery.
+# Used for Middle-Proxy KDF (if nat_probe=true) and link generation.
+stun_servers = [
+    "stun.l.google.com:5349",
+    "stun1.l.google.com:3478",
+    "stun.gmx.net:3478",
+    "stun.l.google.com:19302"
+]
+
+# If UDP STUN is blocked, attempt TCP-based STUN as fallback.
+stun_tcp_fallback = true
+
+# If all STUN fails, use HTTP APIs to discover public IP.
+http_ip_detect_urls = [
+    "https://ifconfig.me/ip",
+    "https://api.ipify.org"
+]
+
+# Cache discovered public IP to this file to survive restarts.
+cache_public_ip_path = "cache/public_ip.txt"
+
+
+# ==============================================================================
+# SERVER BINDING & METRICS
+# ==============================================================================
+
+[server]
+
+# TCP port to listen on.
+# 443 is recommended (looks like normal HTTPS traffic).
+port = 443
+
+# IPv4 bind address. "0.0.0.0" = all interfaces.
+listen_addr_ipv4 = "0.0.0.0"
+
+# IPv6 bind address. "::" = all interfaces.
+listen_addr_ipv6 = "::"
+
+# Unix socket listener (for reverse proxy setups with Nginx/HAProxy).
+# listen_unix_sock = "/var/run/telemt.sock"
+# listen_unix_sock_perm = "0660"
+
+# Enable PROXY protocol header parsing.
+# Set true ONLY if Telemt is behind HAProxy/Nginx that injects PROXY headers.
+# If enabled without a proxy in front, clients will fail to connect.
+proxy_protocol = false
+
+# Prometheus metrics HTTP endpoint port.
+# Uncomment to enable. Access at http://your-server:9090/metrics
+# metrics_port = 9090
+
+# IP ranges allowed to access the metrics endpoint.
+metrics_whitelist = [
+    "127.0.0.1/32",
+    "::1/128"
+]
+
+# ------------------------------------------------------------------------------
+# Listener Overrides
+# Define explicit listeners with specific bind IPs and announce IPs.
+# The announce IP is what gets embedded in tg:// links and sent to ME servers.
+# You MUST set announce to your server's public IP for ME mode to work.
+# ------------------------------------------------------------------------------
+
+# [[server.listeners]]
+# ip = "0.0.0.0"
+# announce = "203.0.113.10"
+# reuse_allow = false
+
+
+# ==============================================================================
+# TIMEOUTS (seconds unless noted)
+# ==============================================================================
+
+[timeouts]
+
+# Maximum time for client to complete FakeTLS + MTProto handshake.
+client_handshake = 15
+
+# Maximum time to establish TCP connection to upstream Telegram DC.
+tg_connect = 10
+
+# TCP keepalive interval for client connections.
+client_keepalive = 60
+
+# Maximum client inactivity before dropping the connection.
+client_ack = 300
+
+# Instant retry count for a single ME endpoint before giving up on it.
+me_one_retry = 3
+
+# Timeout (milliseconds) for a single ME endpoint connection attempt.
+me_one_timeout_ms = 1500
+
+
+# ==============================================================================
+# ANTI-CENSORSHIP / FAKETLS / MASKING
+# This is where Telemt becomes invisible to Deep Packet Inspection.
+# ==============================================================================
+
+[censorship]
+
+# ------------------------------------------------------------------------------
+# TLS Domain Fronting
+# The SNI (Server Name Indication) your proxy presents to connecting clients.
+# Must be a popular, unblocked HTTPS website in your target country.
+# DPI sees traffic to this domain. Choose carefully.
+# Good choices: major CDNs, banks, government sites, search engines.
+# Bad choices: obscure sites, already-blocked domains.
+# ------------------------------------------------------------------------------
+
+tls_domain = "www.google.com"
+
+# ------------------------------------------------------------------------------
+# Active Probe Masking
+# When someone connects but fails the MTProto handshake (wrong secret),
+# they might be an ISP active prober testing if this is a proxy.
+#
+# mask = false: drop the connection (prober knows something is here)
+# mask = true:  transparently proxy them to mask_host (prober sees a real website)
+#
+# With mask enabled, your server is indistinguishable from a real web server
+# to anyone who doesn't have the correct secret.
+# ------------------------------------------------------------------------------
+
+mask = true
+
+# The real web server to forward failed handshakes to.
+# If omitted, defaults to tls_domain.
+# mask_host = "www.google.com"
+
+# Port on the mask host to connect to.
+mask_port = 443
+
+# Inject PROXY protocol header when forwarding to mask host.
+# 0 = disabled, 1 = v1, 2 = v2. Leave disabled unless mask_host expects it.
+# mask_proxy_protocol = 0
+
+# ------------------------------------------------------------------------------
+# TLS Certificate Emulation
+# ------------------------------------------------------------------------------
+
+# Size (bytes) of the locally generated fake TLS certificate.
+# Only used when tls_emulation is disabled.
+fake_cert_len = 2048
+
+# KILLER FEATURE: Real-Time TLS Emulation.
+# Telemt connects to tls_domain, fetches its actual TLS 1.3 certificate chain,
+# and exactly replicates the byte sizes of ServerHello and Certificate records.
+# Defeats DPI that uses TLS record length heuristics to detect proxies.
+# Strongly recommended in censored environments.
+tls_emulation = true
+
+# Directory to cache fetched TLS certificates.
+tls_front_dir = "tlsfront"
+
+# ------------------------------------------------------------------------------
+# ServerHello Timing
+# Real web servers take 30-150ms to respond to ClientHello due to network
+# latency and crypto processing. A proxy responding in <1ms is suspicious.
+# These settings add realistic delay to mimic genuine server behavior.
+# ------------------------------------------------------------------------------
+
+# Minimum delay before sending ServerHello (milliseconds).
+server_hello_delay_min_ms = 50
+
+# Maximum delay before sending ServerHello (milliseconds).
+server_hello_delay_max_ms = 150
+
+# ------------------------------------------------------------------------------
+# TLS Session Tickets
+# Real TLS 1.3 servers send 1-2 NewSessionTicket messages after handshake.
+# A server that sends zero tickets is anomalous and may trigger DPI flags.
+# Set this to match your tls_domain's behavior (usually 2).
+# ------------------------------------------------------------------------------
+
+# tls_new_session_tickets = 0
+
+# ------------------------------------------------------------------------------
+# Full Certificate Frequency
+# When tls_emulation is enabled, this controls how often (per client IP)
+# to send the complete emulated certificate chain.
+#
+# > 0: Subsequent connections within TTL seconds get a smaller cached version.
+#       Saves bandwidth but creates a detectable size difference between
+#       first and repeat connections.
+#
+# = 0: Every connection gets the full certificate. More bandwidth but
+#       perfectly consistent behavior, no anomalies for DPI to detect.
+# ------------------------------------------------------------------------------
+
+tls_full_cert_ttl_secs = 0
+
+# ------------------------------------------------------------------------------
+# ALPN Enforcement
+# Ensure ServerHello responds with the exact ALPN protocol the client requested.
+# Mismatched ALPN (e.g., client asks h2, server says http/1.1) is a DPI red flag.
+# ------------------------------------------------------------------------------
+
+alpn_enforce = true
+
+
+# ==============================================================================
+# ACCESS CONTROL & USERS
+# ==============================================================================
+
+[access]
+
+# ------------------------------------------------------------------------------
+# Replay Attack Protection
+# DPI can record a legitimate user's handshake and replay it later to probe
+# whether the server is a proxy. Telemt remembers recent handshake nonces
+# and rejects duplicates.
+# ------------------------------------------------------------------------------
+
+# Number of nonce slots in the replay detection buffer.
+replay_check_len = 65536
+
+# How long (seconds) to remember nonces before expiring them.
+replay_window_secs = 1800
+
+# Allow clients with incorrect system clocks to connect.
+# false = reject clients with significant time skew (more secure)
+# true  = accept anyone regardless of clock (more permissive)
+ignore_time_skew = false
+
+# ------------------------------------------------------------------------------
+# User Secrets
+# Each user needs a unique 32-character hex string as their secret.
+# Generate with: openssl rand -hex 16
+#
+# This secret is embedded in the tg:// link. Anyone with it can connect.
+# Format: username = "hex_secret"
+# ------------------------------------------------------------------------------
+
+[access.users]
+# alice = "0123456789abcdef0123456789abcdef"
+# bob = "fedcba9876543210fedcba9876543210"
+
+# ------------------------------------------------------------------------------
+# Per-User Connection Limits
+# Limits concurrent TCP connections per user to prevent secret sharing.
+# Uncomment and set for each user as needed.
+# ------------------------------------------------------------------------------
+
+[access.user_max_tcp_conns]
+# alice = 100
+# bob = 50
+
+# ------------------------------------------------------------------------------
+# Per-User Expiration Dates
+# Automatically revoke access after the specified date (ISO 8601 format).
+# ------------------------------------------------------------------------------
+
+[access.user_expirations]
+# alice = "2025-12-31T23:59:59Z"
+# bob = "2026-06-15T00:00:00Z"
+
+# ------------------------------------------------------------------------------
+# Per-User Data Quotas
+# Maximum total bytes transferred per user. Connection refused after limit.
+# ------------------------------------------------------------------------------
+
+[access.user_data_quota]
+# alice = 107374182400
+# bob = 53687091200
+
+# ------------------------------------------------------------------------------
+# Per-User Unique IP Limits
+# Maximum number of different IP addresses that can use this secret
+# at the same time. Highly effective against secret leaking/sharing.
+# Set to 1 for single-device, 2-3 for phone+desktop, etc.
+# ------------------------------------------------------------------------------
+
+[access.user_max_unique_ips]
+# alice = 3
+# bob = 2
+
+
+# ==============================================================================
+# UPSTREAM ROUTING
+# Controls how Telemt connects to Telegram servers (or ME servers).
+# If omitted entirely, uses the OS default route.
+# ==============================================================================
+
+# ------------------------------------------------------------------------------
+# Direct upstream: use the server's own network interface.
+# You can optionally bind to a specific interface or local IP.
+# ------------------------------------------------------------------------------
+
+# [[upstreams]]
+# type = "direct"
+# interface = "eth0"
+# bind_addresses = ["192.0.2.10"]
+# weight = 1
+# enabled = true
+# scopes = "*"
+
+# ------------------------------------------------------------------------------
+# SOCKS5 upstream: route Telegram traffic through a SOCKS5 proxy.
+# Useful if your server's IP is blocked from reaching Telegram DCs.
+# ------------------------------------------------------------------------------
+
+# [[upstreams]]
+# type = "socks5"
+# address = "198.51.100.30:1080"
+# username = "proxy-user"
+# password = "proxy-pass"
+# weight = 1
+# enabled = true
+
+
+# ==============================================================================
+# DATACENTER OVERRIDES
+# Force specific DC IDs to route to specific IP:Port combinations.
+# DC 203 (CDN) is auto-injected by Telemt if not specified here.
+# ==============================================================================
+
+# [dc_overrides]
+# "201" = "149.154.175.50:443"
+# "202" = ["149.154.167.51:443", "149.154.175.100:443"]

config.toml

@@ -32,7 +32,6 @@ show = "*"
 port = 443
 # proxy_protocol = false           # Enable if behind HAProxy/nginx with PROXY protocol
 # metrics_port = 9090
-# metrics_listen = "0.0.0.0:9090"  # Listen address for metrics (overrides metrics_port)
 # metrics_whitelist = ["127.0.0.1", "::1", "0.0.0.0/0"]
 
 [server.api]

contrib/openbsd/telemt.rcd

@@ -1,16 +0,0 @@
-#!/bin/ksh
-# /etc/rc.d/telemt
-#
-# rc.d(8) script for Telemt MTProxy daemon.
-# Tokio runtime does not daemonize itself, so rc_bg=YES is used.
-
-daemon="/usr/local/bin/telemt"
-daemon_user="_telemt"
-daemon_flags="/etc/telemt/config.toml"
-
-. /etc/rc.d/rc.subr
-
-rc_bg=YES
-rc_reload=NO
-
-rc_cmd $1

contrib/systemd/system-user-telemt.conf

@@ -1,3 +0,0 @@
-u telemt - "telemt user" /var/lib/telemt -
-g telemt - -
-m telemt telemt

contrib/systemd/telemt.service

@@ -1,21 +0,0 @@
-[Unit]
-Description=Telemt
-Wants=network-online.target
-After=multi-user.target network.target network-online.target
-
-[Service]
-Type=simple
-User=telemt
-Group=telemt
-WorkingDirectory=/var/lib/telemt
-ExecStart=/usr/bin/telemt /etc/telemt/telemt.toml
-Restart=on-failure
-RestartSec=10
-LimitNOFILE=65536
-AmbientCapabilities=CAP_NET_BIND_SERVICE
-CapabilityBoundingSet=CAP_NET_BIND_SERVICE
-NoNewPrivileges=true
-
-
-[Install]
-WantedBy=multi-user.target

contrib/systemd/tmpfiles-telemt.conf

@@ -1 +0,0 @@
-d /var/lib/telemt 700 telemt telemt

docker-compose.yml

@@ -7,7 +7,6 @@ services:
     ports:
       - "443:443"
       - "127.0.0.1:9090:9090"
-      - "127.0.0.1:9091:9091"
     # Allow caching 'proxy-secret' in read-only container
     working_dir: /run/telemt
     volumes:

docs/API.md

@@ -85,7 +85,6 @@ Notes:
 | `GET` | `/v1/health` | none | `200` | `HealthData` |
 | `GET` | `/v1/system/info` | none | `200` | `SystemInfoData` |
 | `GET` | `/v1/runtime/gates` | none | `200` | `RuntimeGatesData` |
-| `GET` | `/v1/runtime/initialization` | none | `200` | `RuntimeInitializationData` |
 | `GET` | `/v1/limits/effective` | none | `200` | `EffectiveLimitsData` |
 | `GET` | `/v1/security/posture` | none | `200` | `SecurityPostureData` |
 | `GET` | `/v1/security/whitelist` | none | `200` | `SecurityWhitelistData` |
@@ -99,7 +98,6 @@ Notes:
 | `GET` | `/v1/runtime/me_quality` | none | `200` | `RuntimeMeQualityData` |
 | `GET` | `/v1/runtime/upstream_quality` | none | `200` | `RuntimeUpstreamQualityData` |
 | `GET` | `/v1/runtime/nat_stun` | none | `200` | `RuntimeNatStunData` |
-| `GET` | `/v1/runtime/me-selftest` | none | `200` | `RuntimeMeSelftestData` |
 | `GET` | `/v1/runtime/connections/summary` | none | `200` | `RuntimeEdgeConnectionsSummaryData` |
 | `GET` | `/v1/runtime/events/recent` | none | `200` | `RuntimeEdgeEventsData` |
 | `GET` | `/v1/stats/users` | none | `200` | `UserInfo[]` |
@@ -149,12 +147,6 @@ Notes:
 - `PATCH` updates only provided fields and does not support explicit clearing of optional fields.
 - `If-Match` supports both quoted and unquoted values; surrounding whitespace is trimmed.
 
-## Query Parameters
-
-| Endpoint | Query | Behavior |
-| --- | --- | --- |
-| `GET /v1/runtime/events/recent` | `limit=<usize>` | Optional. Invalid/missing value falls back to default `50`. Effective value is clamped to `[1, 1000]` and additionally bounded by ring-buffer capacity. |
-
 ## Request Contracts
 
 ### `CreateUserRequest`
@@ -227,45 +219,6 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `me_runtime_ready` | `bool` | Current ME runtime readiness status used for conditional gate decisions. |
 | `me2dc_fallback_enabled` | `bool` | Whether ME -> direct fallback is enabled. |
 | `use_middle_proxy` | `bool` | Current transport mode preference. |
-| `startup_status` | `string` | Startup status (`pending`, `initializing`, `ready`, `failed`, `skipped`). |
-| `startup_stage` | `string` | Current startup stage identifier. |
-| `startup_progress_pct` | `f64` | Startup progress percentage (`0..100`). |
-
-### `RuntimeInitializationData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `status` | `string` | Startup status (`pending`, `initializing`, `ready`, `failed`, `skipped`). |
-| `degraded` | `bool` | Whether runtime is currently in degraded mode. |
-| `current_stage` | `string` | Current startup stage identifier. |
-| `progress_pct` | `f64` | Overall startup progress percentage (`0..100`). |
-| `started_at_epoch_secs` | `u64` | Process start timestamp (Unix seconds). |
-| `ready_at_epoch_secs` | `u64?` | Timestamp when startup reached ready state; absent until ready. |
-| `total_elapsed_ms` | `u64` | Elapsed startup duration in milliseconds. |
-| `transport_mode` | `string` | Startup transport mode (`middle_proxy` or `direct`). |
-| `me` | `RuntimeInitializationMeData` | ME startup substate snapshot. |
-| `components` | `RuntimeInitializationComponentData[]` | Per-component startup timeline and status. |
-
-#### `RuntimeInitializationMeData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `status` | `string` | ME startup status (`pending`, `initializing`, `ready`, `failed`, `skipped`). |
-| `current_stage` | `string` | Current ME startup stage identifier. |
-| `progress_pct` | `f64` | ME startup progress percentage (`0..100`). |
-| `init_attempt` | `u32` | Current ME init attempt counter. |
-| `retry_limit` | `string` | Retry limit (`"unlimited"` or numeric string). |
-| `last_error` | `string?` | Last ME initialization error text when present. |
-
-#### `RuntimeInitializationComponentData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `id` | `string` | Startup component identifier. |
-| `title` | `string` | Human-readable component title. |
-| `status` | `string` | Component status (`pending`, `running`, `ready`, `failed`, `skipped`). |
-| `started_at_epoch_ms` | `u64?` | Component start timestamp in Unix milliseconds. |
-| `finished_at_epoch_ms` | `u64?` | Component finish timestamp in Unix milliseconds. |
-| `duration_ms` | `u64?` | Component duration in milliseconds. |
-| `attempts` | `u32` | Attempt counter for this component. |
-| `details` | `string?` | Optional short status details text. |
 
 ### `EffectiveLimitsData`
 | Field | Type | Description |
@@ -303,22 +256,11 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `floor_mode` | `string` | Effective floor mode (`static` or `adaptive`). |
 | `adaptive_floor_idle_secs` | `u64` | Adaptive floor idle threshold. |
 | `adaptive_floor_min_writers_single_endpoint` | `u8` | Adaptive floor minimum for single-endpoint DCs. |
-| `adaptive_floor_min_writers_multi_endpoint` | `u8` | Adaptive floor minimum for multi-endpoint DCs. |
 | `adaptive_floor_recover_grace_secs` | `u64` | Adaptive floor recovery grace period. |
-| `adaptive_floor_writers_per_core_total` | `u16` | Target total writers-per-core budget in adaptive mode. |
-| `adaptive_floor_cpu_cores_override` | `u16` | Manual CPU core override (`0` means auto-detect). |
-| `adaptive_floor_max_extra_writers_single_per_core` | `u16` | Extra per-core adaptive headroom for single-endpoint DCs. |
-| `adaptive_floor_max_extra_writers_multi_per_core` | `u16` | Extra per-core adaptive headroom for multi-endpoint DCs. |
-| `adaptive_floor_max_active_writers_per_core` | `u16` | Active writer cap per CPU core. |
-| `adaptive_floor_max_warm_writers_per_core` | `u16` | Warm writer cap per CPU core. |
-| `adaptive_floor_max_active_writers_global` | `u32` | Global active writer cap. |
-| `adaptive_floor_max_warm_writers_global` | `u32` | Global warm writer cap. |
 | `reconnect_max_concurrent_per_dc` | `u32` | Max concurrent reconnects per DC. |
 | `reconnect_backoff_base_ms` | `u64` | Reconnect base backoff. |
 | `reconnect_backoff_cap_ms` | `u64` | Reconnect backoff cap. |
 | `reconnect_fast_retry_count` | `u32` | Number of fast retries before standard backoff strategy. |
-| `writer_pick_mode` | `string` | Writer picker mode (`sorted_rr`, `p2c`). |
-| `writer_pick_sample_size` | `u8` | Candidate sample size for `p2c` picker mode. |
 | `me2dc_fallback` | `bool` | Effective ME -> direct fallback flag. |
 
 #### `EffectiveUserIpPolicyLimits`
@@ -348,354 +290,16 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `entries_total` | `usize` | Number of whitelist CIDR entries. |
 | `entries` | `string[]` | Whitelist CIDR entries as strings. |
 
-### `RuntimeMePoolStateData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Runtime payload availability. |
-| `reason` | `string?` | `source_unavailable` when ME pool snapshot is unavailable. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeMePoolStatePayload?` | Null when unavailable. |
+### Runtime Min Endpoints
+- `/v1/runtime/me_pool_state`: generations, hardswap state, writer contour/health counts, refill inflight snapshot.
+- `/v1/runtime/me_quality`: ME error/drift/reconnect counters and per-DC RTT coverage snapshot.
+- `/v1/runtime/upstream_quality`: upstream runtime policy, connect counters, health summary and per-upstream DC latency/IP preference.
+- `/v1/runtime/nat_stun`: NAT/STUN runtime flags, server lists, reflection cache state and backoff remaining.
 
-#### `RuntimeMePoolStatePayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `generations` | `RuntimeMePoolStateGenerationData` | Active/warm/pending/draining generation snapshot. |
-| `hardswap` | `RuntimeMePoolStateHardswapData` | Hardswap state flags. |
-| `writers` | `RuntimeMePoolStateWriterData` | Writer total/contour/health counters. |
-| `refill` | `RuntimeMePoolStateRefillData` | In-flight refill counters by DC/family. |
-
-#### `RuntimeMePoolStateGenerationData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `active_generation` | `u64` | Active pool generation id. |
-| `warm_generation` | `u64` | Warm pool generation id. |
-| `pending_hardswap_generation` | `u64` | Pending hardswap generation id (`0` when none). |
-| `pending_hardswap_age_secs` | `u64?` | Age of pending hardswap generation in seconds. |
-| `draining_generations` | `u64[]` | Distinct generation ids currently draining. |
-
-#### `RuntimeMePoolStateHardswapData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Hardswap feature toggle. |
-| `pending` | `bool` | `true` when pending generation is non-zero. |
-
-#### `RuntimeMePoolStateWriterData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `total` | `usize` | Total writer rows in snapshot. |
-| `alive_non_draining` | `usize` | Alive writers excluding draining ones. |
-| `draining` | `usize` | Writers marked draining. |
-| `degraded` | `usize` | Non-draining degraded writers. |
-| `contour` | `RuntimeMePoolStateWriterContourData` | Counts by contour state. |
-| `health` | `RuntimeMePoolStateWriterHealthData` | Counts by health bucket. |
-
-#### `RuntimeMePoolStateWriterContourData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `warm` | `usize` | Writers in warm contour. |
-| `active` | `usize` | Writers in active contour. |
-| `draining` | `usize` | Writers in draining contour. |
-
-#### `RuntimeMePoolStateWriterHealthData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `healthy` | `usize` | Non-draining non-degraded writers. |
-| `degraded` | `usize` | Non-draining degraded writers. |
-| `draining` | `usize` | Draining writers. |
-
-#### `RuntimeMePoolStateRefillData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `inflight_endpoints_total` | `usize` | Total in-flight endpoint refill operations. |
-| `inflight_dc_total` | `usize` | Number of distinct DC+family keys with refill in flight. |
-| `by_dc` | `RuntimeMePoolStateRefillDcData[]` | Per-DC refill rows. |
-
-#### `RuntimeMePoolStateRefillDcData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `dc` | `i16` | Telegram DC id. |
-| `family` | `string` | Address family label (`V4`, `V6`). |
-| `inflight` | `usize` | In-flight refill operations for this row. |
-
-### `RuntimeMeQualityData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Runtime payload availability. |
-| `reason` | `string?` | `source_unavailable` when ME pool snapshot is unavailable. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeMeQualityPayload?` | Null when unavailable. |
-
-#### `RuntimeMeQualityPayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `counters` | `RuntimeMeQualityCountersData` | Key ME lifecycle/error counters. |
-| `route_drops` | `RuntimeMeQualityRouteDropData` | Route drop counters by reason. |
-| `dc_rtt` | `RuntimeMeQualityDcRttData[]` | Per-DC RTT and writer coverage rows. |
-
-#### `RuntimeMeQualityCountersData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `idle_close_by_peer_total` | `u64` | Peer-initiated idle closes. |
-| `reader_eof_total` | `u64` | Reader EOF events. |
-| `kdf_drift_total` | `u64` | KDF drift detections. |
-| `kdf_port_only_drift_total` | `u64` | KDF port-only drift detections. |
-| `reconnect_attempt_total` | `u64` | Reconnect attempts. |
-| `reconnect_success_total` | `u64` | Successful reconnects. |
-
-#### `RuntimeMeQualityRouteDropData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `no_conn_total` | `u64` | Route drops with no connection mapping. |
-| `channel_closed_total` | `u64` | Route drops because destination channel is closed. |
-| `queue_full_total` | `u64` | Route drops due queue backpressure (aggregate). |
-| `queue_full_base_total` | `u64` | Route drops in base-queue path. |
-| `queue_full_high_total` | `u64` | Route drops in high-priority queue path. |
-
-#### `RuntimeMeQualityDcRttData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `dc` | `i16` | Telegram DC id. |
-| `rtt_ema_ms` | `f64?` | RTT EMA for this DC. |
-| `alive_writers` | `usize` | Alive writers currently mapped to this DC. |
-| `required_writers` | `usize` | Target writer floor for this DC. |
-| `coverage_pct` | `f64` | `alive_writers / required_writers * 100`. |
-
-### `RuntimeUpstreamQualityData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Runtime payload availability. |
-| `reason` | `string?` | `source_unavailable` when upstream runtime snapshot is unavailable. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `policy` | `RuntimeUpstreamQualityPolicyData` | Effective upstream policy values. |
-| `counters` | `RuntimeUpstreamQualityCountersData` | Upstream connect counters. |
-| `summary` | `RuntimeUpstreamQualitySummaryData?` | Aggregate runtime health summary. |
-| `upstreams` | `RuntimeUpstreamQualityUpstreamData[]?` | Per-upstream runtime rows. |
-
-#### `RuntimeUpstreamQualityPolicyData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `connect_retry_attempts` | `u32` | Upstream connect retry attempts. |
-| `connect_retry_backoff_ms` | `u64` | Upstream retry backoff delay. |
-| `connect_budget_ms` | `u64` | Total connect wall-clock budget. |
-| `unhealthy_fail_threshold` | `u32` | Consecutive fail threshold for unhealthy marking. |
-| `connect_failfast_hard_errors` | `bool` | Whether hard errors skip retries. |
-
-#### `RuntimeUpstreamQualityCountersData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `connect_attempt_total` | `u64` | Total connect attempts. |
-| `connect_success_total` | `u64` | Successful connects. |
-| `connect_fail_total` | `u64` | Failed connects. |
-| `connect_failfast_hard_error_total` | `u64` | Fail-fast hard errors. |
-
-#### `RuntimeUpstreamQualitySummaryData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `configured_total` | `usize` | Total configured upstream entries. |
-| `healthy_total` | `usize` | Upstreams currently healthy. |
-| `unhealthy_total` | `usize` | Upstreams currently unhealthy. |
-| `direct_total` | `usize` | Direct-route upstream entries. |
-| `socks4_total` | `usize` | SOCKS4 upstream entries. |
-| `socks5_total` | `usize` | SOCKS5 upstream entries. |
-| `shadowsocks_total` | `usize` | Shadowsocks upstream entries. |
-
-#### `RuntimeUpstreamQualityUpstreamData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `upstream_id` | `usize` | Runtime upstream index. |
-| `route_kind` | `string` | `direct`, `socks4`, `socks5`, `shadowsocks`. |
-| `address` | `string` | Upstream address (`direct` literal for direct route kind, `host:port` only for proxied upstreams). |
-| `weight` | `u16` | Selection weight. |
-| `scopes` | `string` | Configured scope selector. |
-| `healthy` | `bool` | Current health flag. |
-| `fails` | `u32` | Consecutive fail counter. |
-| `last_check_age_secs` | `u64` | Seconds since last health update. |
-| `effective_latency_ms` | `f64?` | Effective latency score used by selector. |
-| `dc` | `RuntimeUpstreamQualityDcData[]` | Per-DC runtime rows. |
-
-#### `RuntimeUpstreamQualityDcData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `dc` | `i16` | Telegram DC id. |
-| `latency_ema_ms` | `f64?` | Per-DC latency EMA. |
-| `ip_preference` | `string` | `unknown`, `prefer_v4`, `prefer_v6`, `both_work`, `unavailable`. |
-
-### `RuntimeNatStunData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Runtime payload availability. |
-| `reason` | `string?` | `source_unavailable` when shared STUN state is unavailable. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeNatStunPayload?` | Null when unavailable. |
-
-#### `RuntimeNatStunPayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `flags` | `RuntimeNatStunFlagsData` | NAT probe runtime flags. |
-| `servers` | `RuntimeNatStunServersData` | Configured/live STUN server lists. |
-| `reflection` | `RuntimeNatStunReflectionBlockData` | Reflection cache data for v4/v6. |
-| `stun_backoff_remaining_ms` | `u64?` | Remaining retry backoff (milliseconds). |
-
-#### `RuntimeNatStunFlagsData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `nat_probe_enabled` | `bool` | Current NAT probe enable state. |
-| `nat_probe_disabled_runtime` | `bool` | Runtime disable flag due failures/conditions. |
-| `nat_probe_attempts` | `u8` | Configured NAT probe attempt count. |
-
-#### `RuntimeNatStunServersData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `configured` | `string[]` | Configured STUN server entries. |
-| `live` | `string[]` | Runtime live STUN server entries. |
-| `live_total` | `usize` | Number of live STUN entries. |
-
-#### `RuntimeNatStunReflectionBlockData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `v4` | `RuntimeNatStunReflectionData?` | IPv4 reflection data. |
-| `v6` | `RuntimeNatStunReflectionData?` | IPv6 reflection data. |
-
-#### `RuntimeNatStunReflectionData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `addr` | `string` | Reflected public endpoint (`ip:port`). |
-| `age_secs` | `u64` | Reflection value age in seconds. |
-
-### `RuntimeMeSelftestData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Runtime payload availability. |
-| `reason` | `string?` | `source_unavailable` when ME pool is unavailable. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeMeSelftestPayload?` | Null when unavailable. |
-
-#### `RuntimeMeSelftestPayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `kdf` | `RuntimeMeSelftestKdfData` | KDF EWMA health state. |
-| `timeskew` | `RuntimeMeSelftestTimeskewData` | Date-header skew health state. |
-| `ip` | `RuntimeMeSelftestIpData` | Interface IP family classification. |
-| `pid` | `RuntimeMeSelftestPidData` | Process PID marker (`one|non-one`). |
-| `bnd` | `RuntimeMeSelftestBndData` | SOCKS BND.ADDR/BND.PORT health state. |
-
-#### `RuntimeMeSelftestKdfData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `state` | `string` | `ok` or `error` based on EWMA threshold. |
-| `ewma_errors_per_min` | `f64` | EWMA KDF error rate per minute. |
-| `threshold_errors_per_min` | `f64` | Threshold used for `error` decision. |
-| `errors_total` | `u64` | Total source errors (`kdf_drift + socks_kdf_strict_reject`). |
-
-#### `RuntimeMeSelftestTimeskewData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `state` | `string` | `ok` or `error` (`max_skew_secs_15m > 60` => `error`). |
-| `max_skew_secs_15m` | `u64?` | Maximum observed skew in the last 15 minutes. |
-| `samples_15m` | `usize` | Number of skew samples in the last 15 minutes. |
-| `last_skew_secs` | `u64?` | Latest observed skew value. |
-| `last_source` | `string?` | Latest skew source marker. |
-| `last_seen_age_secs` | `u64?` | Age of the latest skew sample. |
-
-#### `RuntimeMeSelftestIpData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `v4` | `RuntimeMeSelftestIpFamilyData?` | IPv4 interface probe result; absent when unknown. |
-| `v6` | `RuntimeMeSelftestIpFamilyData?` | IPv6 interface probe result; absent when unknown. |
-
-#### `RuntimeMeSelftestIpFamilyData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `addr` | `string` | Detected interface IP. |
-| `state` | `string` | `good`, `bogon`, or `loopback`. |
-
-#### `RuntimeMeSelftestPidData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `pid` | `u32` | Current process PID. |
-| `state` | `string` | `one` when PID=1, otherwise `non-one`. |
-
-#### `RuntimeMeSelftestBndData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `addr_state` | `string` | `ok`, `bogon`, or `error`. |
-| `port_state` | `string` | `ok`, `zero`, or `error`. |
-| `last_addr` | `string?` | Latest observed SOCKS BND address. |
-| `last_seen_age_secs` | `u64?` | Age of latest BND sample. |
-
-### `RuntimeEdgeConnectionsSummaryData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Endpoint availability under `runtime_edge_enabled`. |
-| `reason` | `string?` | `feature_disabled` or `source_unavailable`. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeEdgeConnectionsSummaryPayload?` | Null when unavailable. |
-
-#### `RuntimeEdgeConnectionsSummaryPayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `cache` | `RuntimeEdgeConnectionCacheData` | Runtime edge cache metadata. |
-| `totals` | `RuntimeEdgeConnectionTotalsData` | Connection totals block. |
-| `top` | `RuntimeEdgeConnectionTopData` | Top-N leaderboard blocks. |
-| `telemetry` | `RuntimeEdgeConnectionTelemetryData` | Telemetry-policy flags for counters. |
-
-#### `RuntimeEdgeConnectionCacheData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `ttl_ms` | `u64` | Configured cache TTL in milliseconds. |
-| `served_from_cache` | `bool` | `true` when payload is served from cache. |
-| `stale_cache_used` | `bool` | `true` when stale cache is used because recompute is busy. |
-
-#### `RuntimeEdgeConnectionTotalsData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `current_connections` | `u64` | Current global live connections. |
-| `current_connections_me` | `u64` | Current live connections routed through ME. |
-| `current_connections_direct` | `u64` | Current live connections routed through direct path. |
-| `active_users` | `usize` | Users with `current_connections > 0`. |
-
-#### `RuntimeEdgeConnectionTopData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `limit` | `usize` | Effective Top-N row count. |
-| `by_connections` | `RuntimeEdgeConnectionUserData[]` | Users sorted by current connections. |
-| `by_throughput` | `RuntimeEdgeConnectionUserData[]` | Users sorted by cumulative octets. |
-
-#### `RuntimeEdgeConnectionUserData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `username` | `string` | Username. |
-| `current_connections` | `u64` | Current live connections for user. |
-| `total_octets` | `u64` | Cumulative (`client->proxy + proxy->client`) octets. |
-
-#### `RuntimeEdgeConnectionTelemetryData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `user_enabled` | `bool` | Per-user telemetry enable flag. |
-| `throughput_is_cumulative` | `bool` | Always `true` in current implementation. |
-
-### `RuntimeEdgeEventsData`
-| Field | Type | Description |
-| --- | --- | --- |
-| `enabled` | `bool` | Endpoint availability under `runtime_edge_enabled`. |
-| `reason` | `string?` | `feature_disabled` when endpoint is disabled. |
-| `generated_at_epoch_secs` | `u64` | Snapshot generation timestamp. |
-| `data` | `RuntimeEdgeEventsPayload?` | Null when unavailable. |
-
-#### `RuntimeEdgeEventsPayload`
-| Field | Type | Description |
-| --- | --- | --- |
-| `capacity` | `usize` | Effective ring-buffer capacity. |
-| `dropped_total` | `u64` | Count of dropped oldest events due capacity pressure. |
-| `events` | `ApiEventRecord[]` | Recent events in chronological order. |
-
-#### `ApiEventRecord`
-| Field | Type | Description |
-| --- | --- | --- |
-| `seq` | `u64` | Monotonic sequence number. |
-| `ts_epoch_secs` | `u64` | Event timestamp (Unix seconds). |
-| `event_type` | `string` | Event kind identifier. |
-| `context` | `string` | Context text (truncated to implementation-defined max length). |
+### Runtime Edge Endpoints
+- `/v1/runtime/connections/summary`: cached connection totals (`total/me/direct`), active users and top-N users by connections/traffic.
+- `/v1/runtime/events/recent?limit=N`: bounded control-plane ring-buffer events (`limit` clamped to `[1, 1000]`).
+- If `server.api.runtime_edge_enabled=false`, runtime edge endpoints return `enabled=false` with `reason=feature_disabled`.
 
 ### `ZeroAllData`
 | Field | Type | Description |
@@ -758,14 +362,13 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `direct_total` | `usize` | Number of direct upstream entries. |
 | `socks4_total` | `usize` | Number of SOCKS4 upstream entries. |
 | `socks5_total` | `usize` | Number of SOCKS5 upstream entries. |
-| `shadowsocks_total` | `usize` | Number of Shadowsocks upstream entries. |
 
 #### `UpstreamStatus`
 | Field | Type | Description |
 | --- | --- | --- |
 | `upstream_id` | `usize` | Runtime upstream index. |
-| `route_kind` | `string` | Upstream route kind: `direct`, `socks4`, `socks5`, `shadowsocks`. |
-| `address` | `string` | Upstream address (`direct` for direct route kind, `host:port` for Shadowsocks). Authentication fields are intentionally omitted. |
+| `route_kind` | `string` | Upstream route kind: `direct`, `socks4`, `socks5`. |
+| `address` | `string` | Upstream address (`direct` for direct route kind). Authentication fields are intentionally omitted. |
 | `weight` | `u16` | Selection weight. |
 | `scopes` | `string` | Configured scope selector string. |
 | `healthy` | `bool` | Current health flag. |
@@ -882,27 +485,7 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `floor_mode` | `string` | Writer floor mode. |
 | `adaptive_floor_idle_secs` | `u64` | Idle threshold for adaptive floor. |
 | `adaptive_floor_min_writers_single_endpoint` | `u8` | Minimum writers for single-endpoint DC in adaptive mode. |
-| `adaptive_floor_min_writers_multi_endpoint` | `u8` | Minimum writers for multi-endpoint DC in adaptive mode. |
 | `adaptive_floor_recover_grace_secs` | `u64` | Grace period for floor recovery. |
-| `adaptive_floor_writers_per_core_total` | `u16` | Target total writers-per-core budget in adaptive mode. |
-| `adaptive_floor_cpu_cores_override` | `u16` | CPU core override (`0` means auto-detect). |
-| `adaptive_floor_max_extra_writers_single_per_core` | `u16` | Extra single-endpoint writers budget per core. |
-| `adaptive_floor_max_extra_writers_multi_per_core` | `u16` | Extra multi-endpoint writers budget per core. |
-| `adaptive_floor_max_active_writers_per_core` | `u16` | Active writer cap per core. |
-| `adaptive_floor_max_warm_writers_per_core` | `u16` | Warm writer cap per core. |
-| `adaptive_floor_max_active_writers_global` | `u32` | Global active writer cap. |
-| `adaptive_floor_max_warm_writers_global` | `u32` | Global warm writer cap. |
-| `adaptive_floor_cpu_cores_detected` | `u32` | Runtime-detected CPU cores. |
-| `adaptive_floor_cpu_cores_effective` | `u32` | Effective core count used for adaptive caps. |
-| `adaptive_floor_global_cap_raw` | `u64` | Raw global cap before clamping. |
-| `adaptive_floor_global_cap_effective` | `u64` | Effective global cap after clamping. |
-| `adaptive_floor_target_writers_total` | `u64` | Current adaptive total writer target. |
-| `adaptive_floor_active_cap_configured` | `u64` | Configured global active cap. |
-| `adaptive_floor_active_cap_effective` | `u64` | Effective global active cap. |
-| `adaptive_floor_warm_cap_configured` | `u64` | Configured global warm cap. |
-| `adaptive_floor_warm_cap_effective` | `u64` | Effective global warm cap. |
-| `adaptive_floor_active_writers_current` | `u64` | Current active writers count. |
-| `adaptive_floor_warm_writers_current` | `u64` | Current warm writers count. |
 | `me_keepalive_enabled` | `bool` | ME keepalive toggle. |
 | `me_keepalive_interval_secs` | `u64` | Keepalive period. |
 | `me_keepalive_jitter_secs` | `u64` | Keepalive jitter. |
@@ -924,8 +507,6 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `me_single_endpoint_outage_backoff_max_ms` | `u64` | Outage mode max reconnect backoff. |
 | `me_single_endpoint_shadow_rotate_every_secs` | `u64` | Shadow rotation interval. |
 | `me_deterministic_writer_sort` | `bool` | Deterministic writer ordering toggle. |
-| `me_writer_pick_mode` | `string` | Writer picker mode (`sorted_rr`, `p2c`). |
-| `me_writer_pick_sample_size` | `u8` | Candidate sample size for `p2c` picker mode. |
 | `me_socks_kdf_policy` | `string` | Current SOCKS KDF policy mode. |
 | `quarantined_endpoints_total` | `usize` | Total quarantined endpoints. |
 | `quarantined_endpoints` | `MinimalQuarantineData[]` | Quarantine details. |
@@ -991,25 +572,14 @@ Note: the request contract is defined, but the corresponding route currently ret
 | --- | --- | --- |
 | `dc` | `i16` | Telegram DC id. |
 | `endpoints` | `string[]` | Endpoints in this DC (`ip:port`). |
-| `endpoint_writers` | `DcEndpointWriters[]` | Active writer counts grouped by endpoint. |
 | `available_endpoints` | `usize` | Endpoints currently available in this DC. |
 | `available_pct` | `f64` | `available_endpoints / endpoints_total * 100`. |
 | `required_writers` | `usize` | Required writer count for this DC. |
-| `floor_min` | `usize` | Floor lower bound for this DC. |
-| `floor_target` | `usize` | Floor target writer count for this DC. |
-| `floor_max` | `usize` | Floor upper bound for this DC. |
-| `floor_capped` | `bool` | `true` when computed floor target was capped by active limits. |
 | `alive_writers` | `usize` | Alive writers in this DC. |
 | `coverage_pct` | `f64` | `alive_writers / required_writers * 100`. |
 | `rtt_ms` | `f64?` | Aggregated RTT for DC. |
 | `load` | `usize` | Active client sessions bound to this DC. |
 
-#### `DcEndpointWriters`
-| Field | Type | Description |
-| --- | --- | --- |
-| `endpoint` | `string` | Endpoint (`ip:port`). |
-| `active_writers` | `usize` | Active writers currently mapped to endpoint. |
-
 ### `UserInfo`
 | Field | Type | Description |
 | --- | --- | --- |
@@ -1021,9 +591,6 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `max_unique_ips` | `usize?` | Optional unique IP limit. |
 | `current_connections` | `u64` | Current live connections. |
 | `active_unique_ips` | `usize` | Current active unique source IPs. |
-| `active_unique_ips_list` | `ip[]` | Current active unique source IP list. |
-| `recent_unique_ips` | `usize` | Unique source IP count inside the configured recent window. |
-| `recent_unique_ips_list` | `ip[]` | Recent-window unique source IP list. |
 | `total_octets` | `u64` | Total traffic octets for this user. |
 | `links` | `UserLinks` | Active connection links derived from current config. |
 
@@ -1035,15 +602,11 @@ Note: the request contract is defined, but the corresponding route currently ret
 | `tls` | `string[]` | Active `tg://proxy` links for EE-TLS mode (for each host+TLS domain). |
 
 Link generation uses active config and enabled modes:
-- Link port is `general.links.public_port` when configured; otherwise `server.port`.
-- If `general.links.public_host` is non-empty, it is used as the single link host override.
-- If `public_host` is not set, hosts are resolved from `server.listeners` in order:
-  `announce` -> `announce_ip` -> listener bind `ip`.
-- For wildcard listener IPs (`0.0.0.0` / `::`), startup-detected external IP of the same family is used when available.
-- Listener-derived hosts are de-duplicated while preserving first-seen order.
-- If multiple hosts are resolved, API returns links for all resolved hosts in every enabled mode.
-- If no host can be resolved from listeners, fallback is startup-detected `IPv4 -> IPv6`.
-- Final compatibility fallback uses `listen_addr_ipv4`/`listen_addr_ipv6` when routable, otherwise `"UNKNOWN"`.
+- `[general.links].public_host/public_port` have priority.
+- If `public_host` is not set, startup-detected public IPs are used (`IPv4`, `IPv6`, or both when available).
+- Fallback host sources: listener `announce`, `announce_ip`, explicit listener `ip`.
+- Legacy fallback: `listen_addr_ipv4` and `listen_addr_ipv6` when routable.
+- Startup-detected IPs are fixed for process lifetime and refreshed on restart.
 - User rows are sorted by `username` in ascending lexical order.
 
 ### `CreateUserResponse`
@@ -1056,10 +619,10 @@ Link generation uses active config and enabled modes:
 
 | Endpoint | Notes |
 | --- | --- |
-| `POST /v1/users` | Creates user, validates config, then atomically updates only affected `access.*` TOML tables (`access.users` always, plus optional per-user tables present in request). |
-| `PATCH /v1/users/{username}` | Partial update of provided fields only. Missing fields remain unchanged. Current implementation persists full config document on success. |
+| `POST /v1/users` | Creates user and validates resulting config before atomic save. |
+| `PATCH /v1/users/{username}` | Partial update of provided fields only. Missing fields remain unchanged. |
 | `POST /v1/users/{username}/rotate-secret` | Currently returns `404` in runtime route matcher; request schema is reserved for intended behavior. |
-| `DELETE /v1/users/{username}` | Deletes only specified user, removes this user from related optional `access.user_*` maps, blocks last-user deletion, and atomically updates only related `access.*` TOML tables. |
+| `DELETE /v1/users/{username}` | Deletes user and related optional settings. Last user deletion is blocked. |
 
 All mutating endpoints:
 - Respect `read_only` mode.
@@ -1067,10 +630,6 @@ All mutating endpoints:
 - Return new `revision` after successful write.
 - Use process-local mutation lock + atomic write (`tmp + rename`) for config persistence.
 
-Delete path cleanup guarantees:
-- Config cleanup removes only the requested username keys.
-- Runtime unique-IP cleanup removes only this user's limiter and tracked IP state.
-
 ## Runtime State Matrix
 
 | Endpoint | `minimal_runtime_enabled=false` | `minimal_runtime_enabled=true` + source unavailable | `minimal_runtime_enabled=true` + source available |
@@ -1084,28 +643,6 @@ Delete path cleanup guarantees:
 - ME endpoints: ME pool is absent (for example direct-only mode or failed ME initialization).
 - Upstreams endpoint: non-blocking upstream snapshot lock is unavailable at request time.
 
-Additional runtime endpoint behavior:
-
-| Endpoint | Disabled by feature flag | `source_unavailable` condition | Normal mode |
-| --- | --- | --- | --- |
-| `/v1/runtime/me_pool_state` | No | ME pool snapshot unavailable | `enabled=true`, full payload |
-| `/v1/runtime/me_quality` | No | ME pool snapshot unavailable | `enabled=true`, full payload |
-| `/v1/runtime/upstream_quality` | No | Upstream runtime snapshot unavailable | `enabled=true`, full payload |
-| `/v1/runtime/nat_stun` | No | STUN shared state unavailable | `enabled=true`, full payload |
-| `/v1/runtime/me-selftest` | No | ME pool unavailable => `enabled=false`, `reason=source_unavailable` | `enabled=true`, full payload |
-| `/v1/runtime/connections/summary` | `runtime_edge_enabled=false` => `enabled=false`, `reason=feature_disabled` | Recompute lock contention with no cache entry => `enabled=true`, `reason=source_unavailable` | `enabled=true`, full payload |
-| `/v1/runtime/events/recent` | `runtime_edge_enabled=false` => `enabled=false`, `reason=feature_disabled` | Not used in current implementation | `enabled=true`, full payload |
-
-## ME Fallback Behavior Exposed Via API
-
-When `general.use_middle_proxy=true` and `general.me2dc_fallback=true`:
-- Startup does not block on full ME pool readiness; initialization can continue in background.
-- Runtime initialization payload can expose ME stage `background_init` until pool becomes ready.
-- Admission/routing decision uses two readiness grace windows for "ME not ready" periods:
-  `80s` before first-ever readiness is observed (startup grace),
-  `6s` after readiness has been observed at least once (runtime failover timeout).
-- While in fallback window breach, new sessions are routed via Direct-DC; when ME becomes ready, routing returns to Middle mode for new sessions.
-
 ## Serialization Rules
 
 - Success responses always include `revision`.
@@ -1113,7 +650,6 @@ When `general.use_middle_proxy=true` and `general.me2dc_fallback=true`:
 - Optional fields with `skip_serializing_if` are omitted when absent.
 - Nullable payload fields may still be `null` where contract uses `?` (for example `UserInfo` option fields).
 - For `/v1/stats/upstreams`, authentication details of SOCKS upstreams are intentionally omitted.
-- `ip[]` fields are serialized as JSON string arrays (for example `"1.2.3.4"`, `"2001:db8::1"`).
 
 ## Operational Notes
 
@@ -1129,7 +665,7 @@ When `general.use_middle_proxy=true` and `general.me2dc_fallback=true`:
 | Runtime apply path | Successful writes are picked up by existing config watcher/hot-reload path. |
 | Exposure | Built-in TLS/mTLS is not provided. Use loopback bind + reverse proxy if needed. |
 | Pagination | User list currently has no pagination/filtering. |
-| Serialization side effect | Updated TOML table bodies are re-serialized on write. Endpoints that persist full config can still rewrite broader formatting/comments. |
+| Serialization side effect | Config comments/manual formatting are not preserved on write. |
 
 ## Known Limitations (Current Release)
 

docs/FAQ.en.md

@@ -1,122 +1,97 @@
-## How to set up a "proxy sponsor" channel and statistics via the @MTProxybot
+## How to set up "proxy sponsor" channel and statistics via @MTProxybot bot
 
-1. Go to the @MTProxybot.
-2. Enter the `/newproxy` command.
-3. Send your server's IP address and port. For example: `1.2.3.4:443`.
-4. Open the configuration file: `nano /etc/telemt/telemt.toml`.
-5. Copy and send the user secret from the `[access.users]` section to the bot.
-6. Copy the tag provided by the bot. For example: `1234567890abcdef1234567890abcdef`.
+1. Go to @MTProxybot bot.
+2. Enter the command `/newproxy`
+3. Send the server IP and port. For example: 1.2.3.4:443
+4. Open the config `nano /etc/telemt.toml`.
+5. Copy and send the user secret from the [access.users] section to the bot.
+6. Copy the tag received from the bot. For example 1234567890abcdef1234567890abcdef.
 > [!WARNING]
 > The link provided by the bot will not work. Do not copy or use it!
-7. Uncomment the `ad_tag` parameter and enter the tag received from the bot.
-8. Uncomment or add the `use_middle_proxy = true` parameter.
+7. Uncomment the ad_tag parameter and enter the tag received from the bot.
+8. Uncomment/add the parameter `use_middle_proxy = true`.
 
-Configuration example:
+Config example:
 ```toml
 [general]
 ad_tag = "1234567890abcdef1234567890abcdef"
 use_middle_proxy = true
 ```
-9. Save the changes (in nano: Ctrl+S -> Ctrl+X).
-10. Restart the telemt service: `systemctl restart telemt`.
-11. Send the `/myproxies` command to the bot and select the added server.
+9. Save the config. Ctrl+S -> Ctrl+X.
+10. Restart telemt `systemctl restart telemt`.
+11. In the bot, send the command /myproxies and select the added server.
 12. Click the "Set promotion" button.
 13. Send a **public link** to the channel. Private channels cannot be added!
-14. Wait for about 1 hour for the information to update on Telegram servers.
+14. Wait approximately 1 hour for the information to update on Telegram servers.
 > [!WARNING]
-> The sponsored channel will not be displayed to you if you are already subscribed to it.
+> You will not see the "proxy sponsor" if you are already subscribed to the channel.
 
-**You can also configure different sponsored channels for different users:**
+**You can also set up different channels for different users.**
 ```toml
 [access.user_ad_tags]
 hello = "ad_tag"
 hello2 = "ad_tag2"
 ```
 
-## Why do you need a middle proxy (ME)
-https://github.com/telemt/telemt/discussions/167
+## How many people can use 1 link
 
-
-## How many people can use one link
-
-By default, an unlimited number of people can use a single link.  
-However, you can limit the number of unique IP addresses for each user:
+By default, 1 link can be used by any number of people.  
+You can limit the number of IPs using the proxy.
 ```toml
 [access.user_max_unique_ips]
 hello = 1
 ```
-This parameter sets the maximum number of unique IP addresses from which a single link can be used simultaneously. If the first user disconnects, a second one can connect. At the same time, multiple users can connect from a single IP address simultaneously (for example, devices on the same Wi-Fi network).
+This parameter limits how many unique IPs can use 1 link simultaneously. If one user disconnects, a second user can connect. Also, multiple users can sit behind the same IP.
 
 ## How to create multiple different links
 
-1. Generate the required number of secrets using the command: `openssl rand -hex 16`.
-2. Open the configuration file: `nano /etc/telemt/telemt.toml`.
-3. Add new users to the `[access.users]` section:
+1. Generate the required number of secrets `openssl rand -hex 16`
+2. Open the config `nano /etc/telemt.toml`
+3. Add new users.
 ```toml
 [access.users]
 user1 = "00000000000000000000000000000001"
 user2 = "00000000000000000000000000000002"
 user3 = "00000000000000000000000000000003"
 ```
-4. Save the configuration (Ctrl+S -> Ctrl+X). There is no need to restart the telemt service.
-5. Get the ready-to-use links using the command:
-```bash
-curl -s http://127.0.0.1:9091/v1/users | jq
-```
-
-## "Unknown TLS SNI" error
-Usually, this error occurs if you have changed the `tls_domain` parameter, but users continue to connect using old links with the previous domain.
-
-If you need to allow connections with any domains (ignoring SNI mismatches), add the following parameters:
-```toml
-[censorship]
-unknown_sni_action = "mask"
-```
+4. Save the config. Ctrl+S -> Ctrl+X. You don't need to restart telemt.
+5. Get the links via `journalctl -u telemt -n -g "links" --no-pager -o cat | tac`
 
 ## How to view metrics
 
-1. Open the configuration file: `nano /etc/telemt/telemt.toml`.
-2. Add the following parameters:
+1. Open the config `nano /etc/telemt.toml`
+2. Add the following parameters
 ```toml
 [server]
 metrics_port = 9090
 metrics_whitelist = ["127.0.0.1/32", "::1/128", "0.0.0.0/0"]
 ```
-3. Save the changes (Ctrl+S -> Ctrl+X).
-4. After that, metrics will be available at: `SERVER_IP:9090/metrics`. 
+3. Save the config. Ctrl+S -> Ctrl+X.
+4. Metrics are available at SERVER_IP:9090/metrics.
 > [!WARNING]
-> The value `"0.0.0.0/0"` in `metrics_whitelist` opens access to metrics from any IP address. It is recommended to replace it with your personal IP, for example: `"1.2.3.4/32"`.
+> "0.0.0.0/0" in metrics_whitelist opens access from any IP. Replace with your own IP. For example "1.2.3.4"
 
 ## Additional parameters
 
-### Domain in the link instead of IP
-To display a domain instead of an IP address in the connection links, add the following lines to the configuration file:
+### Domain in link instead of IP
+To specify a domain in the links, add to the `[general.links]` section of the config file.
 ```toml
 [general.links]
 public_host = "proxy.example.com"
 ```
 
-### Total server connection limit
-This parameter limits the total number of active connections to the server:
-```toml
-[server]
-max_connections = 10000    # 0 - unlimited, 10000 - default
-```
-
 ### Upstream Manager
-To configure outbound connections (upstreams), add the corresponding parameters to the `[[upstreams]]` section of the configuration file:
-
-#### Binding to an outbound IP address
+To specify an upstream, add to the `[[upstreams]]` section of the config.toml file:
+#### Binding to IP
 ```toml
 [[upstreams]]
 type = "direct"
 weight = 1
 enabled = true
-interface = "192.168.1.100" # Replace with your outbound IP
+interface = "192.168.1.100" # Change to your outgoing IP
 ```
-
-#### Using SOCKS4/5 as an Upstream
-- Without authorization:
+#### SOCKS4/5 as Upstream
+- Without authentication:
 ```toml
 [[upstreams]]
 type = "socks5"            # Specify SOCKS4 or SOCKS5
@@ -125,7 +100,7 @@ weight = 1                 # Set Weight for Scenarios
 enabled = true
 ```
 
-- With authorization:
+- With authentication:
 ```toml
 [[upstreams]]
 type = "socks5"            # Specify SOCKS4 or SOCKS5
@@ -135,17 +110,3 @@ password = "pass"          # Password for Auth on SOCKS-server
 weight = 1                 # Set Weight for Scenarios
 enabled = true
 ```
-
-#### Using Shadowsocks as an Upstream
-For this method to work, the `use_middle_proxy = false` parameter must be set.
-
-```toml
-[general]
-use_middle_proxy = false
-
-[[upstreams]]
-type = "shadowsocks"
-url = "ss://2022-blake3-aes-256-gcm:BASE64_KEY@1.2.3.4:8388"
-weight = 1
-enabled = true
-```

docs/FAQ.ru.md

@@ -1,121 +1,96 @@
 ## Как настроить канал "спонсор прокси" и статистику через бота @MTProxybot
 
-1. Зайдите в бота @MTProxybot.
-2. Введите команду `/newproxy`.
-3. Отправьте IP-адрес и порт сервера. Например: `1.2.3.4:443`.
-4. Откройте файл конфигурации: `nano /etc/telemt/telemt.toml`.
-5. Скопируйте и отправьте боту секрет пользователя из раздела `[access.users]`.
-6. Скопируйте тег (tag), который выдаст бот. Например: `1234567890abcdef1234567890abcdef`.
+1. Зайти в бота @MTProxybot.
+2. Ввести команду `/newproxy`
+3. Отправить IP и порт сервера. Например: 1.2.3.4:443
+4. Открыть конфиг `nano /etc/telemt.toml`.
+5. Скопировать и отправить боту секрет пользователя из раздела [access.users].
+6. Скопировать полученный tag у бота. Например 1234567890abcdef1234567890abcdef.
 > [!WARNING]
-> Ссылка, которую выдает бот, работать не будет. Не копируйте и не используйте её!
-7. Раскомментируйте параметр `ad_tag` и впишите тег, полученный от бота.
-8. Раскомментируйте или добавьте параметр `use_middle_proxy = true`.
+> Ссылка, которую выдает бот, не будет работать. Не копируйте и не используйте её!
+7. Раскомментировать параметр ad_tag и вписать tag, полученный у бота.
+8. Раскомментировать/добавить параметр use_middle_proxy = true.
 
-Пример конфигурации:
+Пример конфига:
 ```toml
 [general]
 ad_tag = "1234567890abcdef1234567890abcdef"
 use_middle_proxy = true
 ```
-9. Сохраните изменения (в nano: Ctrl+S -> Ctrl+X).
-10. Перезапустите службу telemt: `systemctl restart telemt`.
-11. В боте отправьте команду `/myproxies` и выберите добавленный сервер.
-12. Нажмите кнопку «Set promotion».
-13. Отправьте **публичную ссылку** на канал. Приватные каналы добавлять нельзя!
-14. Подождите примерно 1 час, пока информация обновится на серверах Telegram.
+9.  Сохранить конфиг. Ctrl+S -> Ctrl+X.
+10. Перезапустить telemt `systemctl restart telemt`.
+11. В боте отправить команду /myproxies и выбрать добавленный сервер.
+12. Нажать кнопку "Set promotion".
+13. Отправить **публичную ссылку** на канал. Приватный канал добавить нельзя!
+14. Подождать примерно 1 час, пока информация обновится на серверах Telegram.
 > [!WARNING]
-> Спонсорский канал не будет у вас отображаться, если вы уже на него подписаны.
+> У вас не будет отображаться "спонсор прокси" если вы уже подписаны на канал.
 
-**Вы также можете настроить разные спонсорские каналы для разных пользователей:**
+**Также вы можете настроить разные каналы для разных пользователей.**
 ```toml
 [access.user_ad_tags]
 hello = "ad_tag"
 hello2 = "ad_tag2"
 ```
 
-## Зачем нужен middle proxy (ME)
-https://github.com/telemt/telemt/discussions/167
+## Сколько человек может пользоваться 1 ссылкой
 
-
-## Сколько человек может пользоваться одной ссылкой
-
-По умолчанию одной ссылкой может пользоваться неограниченное число людей.  
-Однако вы можете ограничить количество уникальных IP-адресов для каждого пользователя:
+По умолчанию 1 ссылкой может пользоваться сколько угодно человек.  
+Вы можете ограничить число IP, использующих прокси.
 ```toml
 [access.user_max_unique_ips]
 hello = 1
 ```
-Этот параметр задает максимальное количество уникальных IP-адресов, с которых можно одновременно использовать одну ссылку. Если первый пользователь отключится, второй сможет подключиться. При этом с одного IP-адреса могут подключаться несколько пользователей одновременно (например, устройства в одной Wi-Fi сети).
+Этот параметр ограничивает, сколько уникальных IP может использовать 1 ссылку одновременно. Если один пользователь отключится, второй сможет подключиться. Также с одного IP может сидеть несколько пользователей.
 
-## Как создать несколько разных ссылок
+## Как сделать несколько разных ссылок
 
-1. Сгенерируйте необходимое количество секретов с помощью команды: `openssl rand -hex 16`.
-2. Откройте файл конфигурации: `nano /etc/telemt/telemt.toml`.
-3. Добавьте новых пользователей в секцию `[access.users]`:
+1. Сгенерируйте нужное число секретов `openssl rand -hex 16`
+2. Открыть конфиг `nano /etc/telemt.toml`
+3. Добавить новых пользователей.
 ```toml
 [access.users]
 user1 = "00000000000000000000000000000001"
 user2 = "00000000000000000000000000000002"
 user3 = "00000000000000000000000000000003"
 ```
-4. Сохраните конфигурацию (Ctrl+S -> Ctrl+X). Перезапускать службу telemt не нужно.
-5. Получите готовые ссылки с помощью команды:
-```bash
-curl -s http://127.0.0.1:9091/v1/users | jq
-```
-
-## Ошибка "Unknown TLS SNI"
-Обычно эта ошибка возникает, если вы изменили параметр `tls_domain`, но пользователи продолжают подключаться по старым ссылкам с прежним доменом.
-
-Если необходимо разрешить подключение с любыми доменами (игнорируя несовпадения SNI), добавьте следующие параметры:
-```toml
-[censorship]
-unknown_sni_action = "mask"
-```
+4. Сохранить конфиг. Ctrl+S -> Ctrl+X. Перезапускать telemt не нужно.
+5. Получить ссылки через `journalctl -u telemt -n -g "links" --no-pager -o cat | tac`
 
 ## Как посмотреть метрики
 
-1. Откройте файл конфигурации: `nano /etc/telemt/telemt.toml`.
-2. Добавьте следующие параметры:
+1. Открыть конфиг `nano /etc/telemt.toml`
+2. Добавить следующие параметры
 ```toml
 [server]
 metrics_port = 9090
 metrics_whitelist = ["127.0.0.1/32", "::1/128", "0.0.0.0/0"]
 ```
-3. Сохраните изменения (Ctrl+S -> Ctrl+X).
-4. После этого метрики будут доступны по адресу: `SERVER_IP:9090/metrics`. 
+3. Сохранить конфиг. Ctrl+S -> Ctrl+X.
+4. Метрики доступны по адресу SERVER_IP:9090/metrics. 
 > [!WARNING]
-> Значение `"0.0.0.0/0"` в `metrics_whitelist` открывает доступ к метрикам с любого IP-адреса. Рекомендуется заменить его на ваш личный IP, например: `"1.2.3.4/32"`.
+> "0.0.0.0/0" в metrics_whitelist открывает доступ с любого IP. Замените на свой ip. Например "1.2.3.4"
 
 ## Дополнительные параметры
 
 ### Домен в ссылке вместо IP
-Чтобы в ссылках для подключения отображался домен вместо IP-адреса, добавьте следующие строки в файл конфигурации:
+Чтобы указать домен в ссылках, добавьте в секцию `[general.links]` файла config.
 ```toml
 [general.links]
 public_host = "proxy.example.com"
 ```
 
-### Общий лимит подключений к серверу
-Этот параметр ограничивает общее количество активных подключений к серверу:
-```toml
-[server]
-max_connections = 10000    # 0 - без ограничений, 10000 - по умолчанию
-```
-
 ### Upstream Manager
-Для настройки исходящих подключений (апстримов) добавьте соответствующие параметры в секцию `[[upstreams]]` файла конфигурации:
-
-#### Привязка к исходящему IP-адресу
+Чтобы указать апстрим, добавьте в секцию `[[upstreams]]` файла config.toml:
+#### Привязка к IP
 ```toml
 [[upstreams]]
 type = "direct"
 weight = 1
 enabled = true
-interface = "192.168.1.100" # Замените на ваш исходящий IP
+interface = "192.168.1.100" # Change to your outgoing IP
 ```
-
-#### Использование SOCKS4/5 в качестве Upstream
+#### SOCKS4/5 как Upstream
 - Без авторизации:
 ```toml
 [[upstreams]]
@@ -135,17 +110,3 @@ password = "pass"          # Password for Auth on SOCKS-server
 weight = 1                 # Set Weight for Scenarios
 enabled = true
 ```
-
-#### Использование Shadowsocks в качестве Upstream
-Для работы этого метода требуется установить параметр `use_middle_proxy = false`.
-
-```toml
-[general]
-use_middle_proxy = false
-
-[[upstreams]]
-type = "shadowsocks"
-url = "ss://2022-blake3-aes-256-gcm:BASE64_KEY@1.2.3.4:8388"
-weight = 1
-enabled = true
-```

docs/LICENSE/LICENSE.de.md

@@ -1,92 +0,0 @@
-# Öffentliche TELEMT-Lizenz 3
-
-***Alle Rechte vorbehalten (c) 2026 Telemt***
-
-Hiermit wird jeder Person, die eine Kopie dieser Software und der dazugehörigen Dokumentation (nachfolgend "Software") erhält, unentgeltlich die Erlaubnis erteilt, die Software ohne Einschränkungen zu nutzen, einschließlich des Rechts, die Software zu verwenden, zu vervielfältigen, zu ändern, abgeleitete Werke zu erstellen, zu verbinden, zu veröffentlichen, zu verbreiten, zu unterlizenzieren und/oder Kopien der Software zu verkaufen sowie diese Rechte auch denjenigen einzuräumen, denen die Software zur Verfügung gestellt wird, vorausgesetzt, dass sämtliche Urheberrechtshinweise sowie die Bedingungen und Bestimmungen dieser Lizenz eingehalten werden.
-
-### Begriffsbestimmungen
-
-Für die Zwecke dieser Lizenz gelten die folgenden Definitionen:
-
-**"Software" (Software)** — die Telemt-Software einschließlich Quellcode, Dokumentation und sämtlicher zugehöriger Dateien, die unter den Bedingungen dieser Lizenz verbreitet werden.
-
-**"Contributor" (Contributor)** — jede natürliche oder juristische Person, die Code, Patches, Dokumentation oder andere Materialien eingereicht hat, die von den Maintainers des Projekts angenommen und in die Software aufgenommen wurden.
-
-**"Beitrag" (Contribution)** — jedes urheberrechtlich geschützte Werk, das bewusst zur Aufnahme in die Software eingereicht wurde.
-
-**"Modifizierte Version" (Modified Version)** — jede Version der Software, die gegenüber der ursprünglichen Software geändert, angepasst, erweitert oder anderweitig modifiziert wurde.
-
-**"Maintainers" (Maintainers)** — natürliche oder juristische Personen, die für das offizielle Telemt-Projekt und dessen offizielle Veröffentlichungen verantwortlich sind.
-
-### 1 Urheberrechtshinweis (Attribution)
-
-Bei der Weitergabe der Software, sowohl in Form des Quellcodes als auch in binärer Form, MÜSSEN folgende Elemente erhalten bleiben:
-
-- der oben genannte Urheberrechtshinweis;
-- der vollständige Text dieser Lizenz;
-- sämtliche bestehenden Hinweise auf Urheberschaft.
-
-### 2 Hinweis auf Modifikationen
-
-Wenn Änderungen an der Software vorgenommen werden, MUSS die Person, die diese Änderungen vorgenommen hat, eindeutig darauf hinweisen, dass die Software modifiziert wurde, und eine kurze Beschreibung der vorgenommenen Änderungen beifügen.
-
-Modifizierte Versionen der Software DÜRFEN NICHT als die originale Version von Telemt dargestellt werden.
-
-### 3 Marken und Bezeichnungen
-
-Diese Lizenz GEWÄHRT KEINE Rechte zur Nutzung der Bezeichnung **"Telemt"**, des Telemt-Logos oder sonstiger Marken, Kennzeichen oder Branding-Elemente von Telemt.
-
-Weiterverbreitete oder modifizierte Versionen der Software DÜRFEN die Bezeichnung Telemt nicht in einer Weise verwenden, die bei Nutzern den Eindruck eines offiziellen Ursprungs oder einer Billigung durch das Telemt-Projekt erwecken könnte, sofern hierfür keine ausdrückliche Genehmigung der Maintainers vorliegt.
-
-Die Verwendung der Bezeichnung **Telemt** zur Beschreibung einer modifizierten Version der Software ist nur zulässig, wenn diese Version eindeutig als modifiziert oder inoffiziell gekennzeichnet ist.
-
-Jegliche Verbreitung, die Nutzer vernünftigerweise darüber täuschen könnte, dass es sich um eine offizielle Veröffentlichung von Telemt handelt, ist untersagt.
-
-### 4 Transparenz bei der Verbreitung von Binärversionen
-
-Im Falle der Verbreitung kompilierter Binärversionen der Software wird der Verbreiter HIERMIT ERMUTIGT (encouraged), soweit dies vernünftigerweise möglich ist, Zugang zum entsprechenden Quellcode sowie zu den Build-Anweisungen bereitzustellen.
-
-Diese Praxis trägt zur Transparenz bei und ermöglicht es Empfängern, die Integrität und Reproduzierbarkeit der verbreiteten Builds zu überprüfen.
-
-## 5 Gewährung einer Patentlizenz und Beendigung von Rechten
-
-Jeder Contributor gewährt den Empfängern der Software eine unbefristete, weltweite, nicht-exklusive, unentgeltliche, lizenzgebührenfreie und unwiderrufliche Patentlizenz für:
-
-- die Herstellung,
-- die Beauftragung der Herstellung,
-- die Nutzung,
-- das Anbieten zum Verkauf,
-- den Verkauf,
-- den Import,
-- sowie jede sonstige Verbreitung der Software.
-
-Diese Patentlizenz erstreckt sich ausschließlich auf solche Patentansprüche, die notwendigerweise durch den jeweiligen Beitrag des Contributors allein oder in Kombination mit der Software verletzt würden.
-
-Leitet eine Person ein Patentverfahren ein oder beteiligt sich daran, einschließlich Gegenklagen oder Kreuzklagen, mit der Behauptung, dass die Software oder ein darin enthaltener Beitrag ein Patent verletzt, **erlöschen sämtliche durch diese Lizenz gewährten Rechte für diese Person unmittelbar mit Einreichung der Klage**.
-
-Darüber hinaus erlöschen alle durch diese Lizenz gewährten Rechte **automatisch**, wenn eine Person ein gerichtliches Verfahren einleitet, in dem behauptet wird, dass die Software selbst ein Patent oder andere Rechte des geistigen Eigentums verletzt.
-
-### 6 Beteiligung und Beiträge zur Entwicklung
-
-Sofern ein Contributor nicht ausdrücklich etwas anderes erklärt, gilt jeder Beitrag, der bewusst zur Aufnahme in die Software eingereicht wird, als unter den Bedingungen dieser Lizenz lizenziert.
-
-Durch die Einreichung eines Beitrags gewährt der Contributor den Maintainers des Telemt-Projekts sowie allen Empfängern der Software die in dieser Lizenz beschriebenen Rechte in Bezug auf diesen Beitrag.
-
-### 7 Urheberhinweis bei Netzwerk- und Servicenutzung
-
-Wird die Software zur Bereitstellung eines öffentlich zugänglichen Netzwerkdienstes verwendet, MUSS der Betreiber dieses Dienstes einen Hinweis auf die Urheberschaft von Telemt an mindestens einer der folgenden Stellen anbringen:
-
-* in der Servicedokumentation;
-* in der Dienstbeschreibung;
-* auf einer Seite "Über" oder einer vergleichbaren Informationsseite;
-* in anderen für Nutzer zugänglichen Materialien, die in angemessenem Zusammenhang mit dem Dienst stehen.
-
-Ein solcher Hinweis DARF NICHT den Eindruck erwecken, dass der Dienst vom Telemt-Projekt oder dessen Maintainers unterstützt oder offiziell gebilligt wird.
-
-### 8 Haftungsausschluss und salvatorische Klausel
-
-DIE SOFTWARE WIRD "WIE BESEHEN" BEREITGESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF GEWÄHRLEISTUNGEN DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG VON RECHTEN.
-
-IN KEINEM FALL HAFTEN DIE AUTOREN ODER RECHTEINHABER FÜR IRGENDWELCHE ANSPRÜCHE, SCHÄDEN ODER SONSTIGE HAFTUNG, DIE AUS VERTRAG, UNERLAUBTER HANDLUNG ODER AUF ANDERE WEISE AUS DER SOFTWARE ODER DER NUTZUNG DER SOFTWARE ENTSTEHEN.
-
-SOLLTE EINE BESTIMMUNG DIESER LIZENZ ALS UNWIRKSAM ODER NICHT DURCHSETZBAR ANGESEHEN WERDEN, IST DIESE BESTIMMUNG SO AUSZULEGEN, DASS SIE DEM URSPRÜNGLICHEN WILLEN DER PARTEIEN MÖGLICHST NAHEKOMMT; DIE ÜBRIGEN BESTIMMUNGEN BLEIBEN DAVON UNBERÜHRT UND IN VOLLER WIRKUNG.

docs/LICENSE/LICENSE.en.md

@@ -1,143 +0,0 @@
-###### TELEMT Public License 3 ######
-##### Copyright (c) 2026 Telemt #####
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this Software and associated documentation files (the "Software"),
-to use, reproduce, modify, prepare derivative works of, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, provided that all
-copyright notices, license terms, and conditions set forth in this License
-are preserved and complied with.
-
-### Official Translations
-
-The canonical version of this License is the English version.
-
-Official translations are provided for informational purposes only
-and for convenience, and do not have legal force. In case of any
-discrepancy, the English version of this License shall prevail.
-
-Available versions:
-- English in Markdown: docs/LICENSE/LICENSE.md
-- German: docs/LICENSE/LICENSE.de.md
-- Russian: docs/LICENSE/LICENSE.ru.md
-
-### Definitions
-
-For the purposes of this License:
-
-"Software" means the Telemt software, including source code, documentation,
-and any associated files distributed under this License.
-
-"Contributor" means any person or entity that submits code, patches,
-documentation, or other contributions to the Software that are accepted
-into the Software by the maintainers.
-
-"Contribution" means any work of authorship intentionally submitted
-to the Software for inclusion in the Software.
-
-"Modified Version" means any version of the Software that has been
-changed, adapted, extended, or otherwise modified from the original
-Software.
-
-"Maintainers" means the individuals or entities responsible for
-the official Telemt project and its releases.
-
-#### 1 Attribution
-
-Redistributions of the Software, in source or binary form, MUST RETAIN the
-above copyright notice, this license text, and any existing attribution
-notices.
-
-#### 2 Modification Notice
-
-If you modify the Software, you MUST clearly state that the Software has been
-modified and include a brief description of the changes made.
-
-Modified versions MUST NOT be presented as the original Telemt.
-
-#### 3 Trademark and Branding
-
-This license DOES NOT grant permission to use the name "Telemt", 
-the Telemt logo, or any Telemt trademarks or branding.
-
-Redistributed or modified versions of the Software MAY NOT use the Telemt
-name in a way that suggests endorsement or official origin without explicit
-permission from the Telemt maintainers.
-
-Use of the name "Telemt" to describe a modified version of the Software
-is permitted only if the modified version is clearly identified as a
-modified or unofficial version.
-
-Any distribution that could reasonably confuse users into believing that
-the software is an official Telemt release is prohibited.
-
-#### 4 Binary Distribution Transparency
-
-If you distribute compiled binaries of the Software,
-you are ENCOURAGED to provide access to the corresponding
-source code and build instructions where reasonably possible.
-
-This helps preserve transparency and allows recipients to verify the
-integrity and reproducibility of distributed builds.
-
-#### 5 Patent Grant and Defensive Termination Clause
-
-Each contributor grants you a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable patent license to make, have made,
-use, offer to sell, sell, import, and otherwise transfer the Software.
-
-This patent license applies only to those patent claims necessarily
-infringed by the contributor’s contribution alone or by combination of
-their contribution with the Software.
-
-If you initiate or participate in any patent litigation, including
-cross-claims or counterclaims, alleging that the Software or any
-contribution incorporated within the Software constitutes patent
-infringement, then **all rights granted to you under this license shall
-terminate immediately** as of the date such litigation is filed.
-
-Additionally, if you initiate legal action alleging that the
-Software itself infringes your patent or other intellectual
-property rights, then all rights granted to you under this
-license SHALL TERMINATE automatically.
-
-#### 6 Contributions
-
-Unless you explicitly state otherwise, any Contribution intentionally
-submitted for inclusion in the Software shall be licensed under the terms
-of this License.
-
-By submitting a Contribution, you grant the Telemt maintainers and all
-recipients of the Software the rights described in this License with
-respect to that Contribution.
-
-#### 7 Network Use Attribution
-
-If the Software is used to provide a publicly accessible network service,
-the operator of such service MUST provide attribution to Telemt in at least
-one of the following locations:
-
-- service documentation
-- service description
-- an "About" or similar informational page
-- other user-visible materials reasonably associated with the service
-
-Such attribution MUST NOT imply endorsement by the Telemt project or its
-maintainers.
-
-#### 8 Disclaimer of Warranty and Severability Clause
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-USE OR OTHER DEALINGS IN THE SOFTWARE
-
-IF ANY PROVISION OF THIS LICENSE IS HELD TO BE INVALID OR UNENFORCEABLE,
-SUCH PROVISION SHALL BE INTERPRETED TO REFLECT THE ORIGINAL INTENT
-OF THE PARTIES AS CLOSELY AS POSSIBLE, AND THE REMAINING PROVISIONS
-SHALL REMAIN IN FULL FORCE AND EFFECT

docs/LICENSE/LICENSE.ru.md

@@ -1,90 +0,0 @@
-# Публичная лицензия TELEMT 3
-
-***Все права защищёны (c) 2026 Telemt***
-
-Настоящим любому лицу, получившему копию данного программного обеспечения и сопутствующей документации (далее — "Программное обеспечение"), безвозмездно предоставляется разрешение использовать Программное обеспечение без ограничений, включая право использовать, воспроизводить, изменять, создавать производные произведения, объединять, публиковать, распространять, сублицензировать и (или) продавать копии Программного обеспечения, а также предоставлять такие права лицам, которым предоставляется Программное обеспечение, при условии соблюдения всех уведомлений об авторских правах, условий и положений настоящей Лицензии.
-
-### Определения
-
-Для целей настоящей Лицензии применяются следующие определения:
-
-**"Программное обеспечение" (Software)** — программное обеспечение Telemt, включая исходный код, документацию и любые связанные файлы, распространяемые на условиях настоящей Лицензии.
-
-**"Контрибьютор" (Contributor)** — любое физическое или юридическое лицо, направившее код, исправления (патчи), документацию или иные материалы, которые были приняты мейнтейнерами проекта и включены в состав Программного обеспечения.
-
-**"Вклад" (Contribution)** — любое произведение авторского права, намеренно представленное для включения в состав Программного обеспечения.
-
-**"Модифицированная версия" (Modified Version)** — любая версия Программного обеспечения, которая была изменена, адаптирована, расширена или иным образом модифицирована по сравнению с исходным Программным обеспечением.
-
-**"Мейнтейнеры" (Maintainers)** — физические или юридические лица, ответственные за официальный проект Telemt и его официальные релизы.
-
-### 1 Указание авторства
-
-При распространении Программного обеспечения, как в форме исходного кода, так и в бинарной форме, ДОЛЖНЫ СОХРАНЯТЬСЯ:
-
-- указанное выше уведомление об авторских правах;
-- текст настоящей Лицензии;
-- любые существующие уведомления об авторстве.
-
-### 2 Уведомление о модификации
-
-В случае внесения изменений в Программное обеспечение лицо, осуществившее такие изменения, ОБЯЗАНО явно указать, что Программное обеспечение было модифицировано, а также включить краткое описание внесённых изменений.
-
-Модифицированные версии Программного обеспечения НЕ ДОЛЖНЫ представляться как оригинальная версия Telemt.
-
-### 3 Товарные знаки и обозначения
-
-Настоящая Лицензия НЕ ПРЕДОСТАВЛЯЕТ права использовать наименование **"Telemt"**, логотип Telemt, а также любые товарные знаки, фирменные обозначения или элементы бренда Telemt.
-
-Распространяемые или модифицированные версии Программного обеспечения НЕ ДОЛЖНЫ использовать наименование Telemt таким образом, который может создавать у пользователей впечатление официального происхождения либо одобрения со стороны проекта Telemt без явного разрешения мейнтейнеров проекта.
-
-Использование наименования **Telemt** для описания модифицированной версии Программного обеспечения допускается только при условии, что такая версия ясно обозначена как модифицированная или неофициальная.
-
-Запрещается любое распространение, которое может разумно вводить пользователей в заблуждение относительно того, что программное обеспечение является официальным релизом Telemt.
-
-### 4 Прозрачность распространения бинарных версий
-
-В случае распространения скомпилированных бинарных версий Программного обеспечения распространитель НАСТОЯЩИМ ПОБУЖДАЕТСЯ предоставлять доступ к соответствующему исходному коду и инструкциям по сборке, если это разумно возможно.
-
-Такая практика способствует прозрачности распространения и позволяет получателям проверять целостность и воспроизводимость распространяемых сборок.
-
-### 5 Предоставление патентной лицензии и прекращение прав
-
-Каждый контрибьютор предоставляет получателям Программного обеспечения бессрочную, всемирную, неисключительную, безвозмездную, не требующую выплаты роялти и безотзывную патентную лицензию на:
-
-- изготовление,
-- поручение изготовления,
-- использование,
-- предложение к продаже,
-- продажу,
-- импорт,
-- и иное распространение Программного обеспечения.
-
-Такая патентная лицензия распространяется исключительно на те патентные требования, которые неизбежно нарушаются соответствующим вкладом контрибьютора как таковым либо его сочетанием с Программным обеспечением.
-
-Если лицо инициирует либо участвует в каком-либо судебном разбирательстве по патентному спору, включая встречные или перекрёстные иски, утверждая, что Программное обеспечение либо любой вклад, включённый в него, нарушает патент, **все права, предоставленные такому лицу настоящей Лицензией, немедленно прекращаются** с даты подачи соответствующего иска.
-
-Кроме того, если лицо инициирует судебное разбирательство, утверждая, что само Программное обеспечение нарушает его патентные либо иные права интеллектуальной собственности, все права, предоставленные настоящей Лицензией, **автоматически прекращаются**.
-
-### 6 Участие и вклад в разработку
-
-Если контрибьютор явно не указал иное, любой Вклад, намеренно представленный для включения в Программное обеспечение, считается лицензированным на условиях настоящей Лицензии.
-Путём предоставления Вклада контрибьютор предоставляет мейнтейнером проекта Telemt и всем получателям Программного обеспечения права, предусмотренные настоящей Лицензией, в отношении такого Вклада.
-
-### 7 Указание авторства при сетевом и сервисном использовании
-
-В случае использования Программного обеспечения для предоставления публично доступного сетевого сервиса оператор такого сервиса ОБЯЗАН обеспечить указание авторства Telemt как минимум в одном из следующих мест:
-- документация сервиса;
-- описание сервиса;
-- страница "О программе" или аналогичная информационная страница;
-- иные материалы, доступные пользователям и разумно связанные с данным сервисом.
-
-Такое указание авторства НЕ ДОЛЖНО создавать впечатление одобрения или официальной поддержки со стороны проекта Telemt либо его мейнтейнеров.
-
-### 8 Отказ от гарантий и делимость положений
-
-ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ "КАК ЕСТЬ", БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ГАРАНТИЯМИ КОММЕРЧЕСКОЙ ПРИГОДНОСТИ, ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ И НЕНАРУШЕНИЯ ПРАВ.
-
-НИ ПРИ КАКИХ ОБСТОЯТЕЛЬСТВАХ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ТРЕБОВАНИЯМ, УБЫТКАМ ИЛИ ИНОЙ ОТВЕТСТВЕННОСТИ, ВОЗНИКАЮЩЕЙ В РЕЗУЛЬТАТЕ ДОГОВОРА, ДЕЛИКТА ИЛИ ИНЫМ ОБРАЗОМ, СВЯЗАННЫМ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ ИЛИ ЕГО ИСПОЛЬЗОВАНИЕМ.
-
-В СЛУЧАЕ ЕСЛИ КАКОЕ-ЛИБО ПОЛОЖЕНИЕ НАСТОЯЩЕЙ ЛИЦЕНЗИИ ПРИЗНАЁТСЯ НЕДЕЙСТВИТЕЛЬНЫМ ИЛИ НЕПРИМЕНИМЫМ, ТАКОЕ ПОЛОЖЕНИЕ ПОДЛЕЖИТ ТОЛКОВАНИЮ МАКСИМАЛЬНО БЛИЗКО К ИСХОДНОМУ НАМЕРЕНИЮ СТОРОН, ПРИ ЭТОМ ОСТАЛЬНЫЕ ПОЛОЖЕНИЯ СОХРАНЯЮТ ПОЛНУЮ ЮРИДИЧЕСКУЮ СИЛУ.

docs/OPENBSD.en.md

@@ -1,132 +0,0 @@
-# Telemt on OpenBSD (Build, Run, and rc.d)
-
-This guide covers a practical OpenBSD deployment flow for Telemt:
-- build from source,
-- install binary and config,
-- run as an rc.d daemon,
-- verify basic runtime behavior.
-
-## 1. Prerequisites
-
-Install required packages:
-
-```sh
-doas pkg_add rust git
-```
-
-Notes:
-- Telemt release installer (`install.sh`) is Linux-only.
-- On OpenBSD, use source build with `cargo`.
-
-## 2. Build from source
-
-```sh
-git clone https://github.com/telemt/telemt
-cd telemt
-cargo build --release
-./target/release/telemt --version
-```
-
-For low-RAM systems, this repository already uses `lto = "thin"` in release profile.
-
-## 3. Install binary and config
-
-```sh
-doas install -d -m 0755 /usr/local/bin
-doas install -m 0755 ./target/release/telemt /usr/local/bin/telemt
-
-doas install -d -m 0750 /etc/telemt
-doas install -m 0640 ./config.toml /etc/telemt/config.toml
-```
-
-## 4. Create runtime user
-
-```sh
-doas useradd -L daemon -s /sbin/nologin -d /var/empty _telemt
-```
-
-If `_telemt` already exists, continue.
-
-## 5. Install rc.d service
-
-Install the provided script:
-
-```sh
-doas install -m 0555 ./contrib/openbsd/telemt.rcd /etc/rc.d/telemt
-```
-
-Enable and start:
-
-```sh
-doas rcctl enable telemt
-# Optional: send daemon output to syslog
-#doas rcctl set telemt logger daemon.info
-
-doas rcctl start telemt
-```
-
-Service controls:
-
-```sh
-doas rcctl check telemt
-doas rcctl restart telemt
-doas rcctl stop telemt
-```
-
-## 6. Resource limits (recommended)
-
-OpenBSD rc.d can apply limits via login class. Add class `telemt` and assign it to `_telemt`.
-
-Example class entry:
-
-```text
-telemt:\
-    :openfiles-cur=8192:openfiles-max=16384:\
-    :datasize-cur=768M:datasize-max=1024M:\
-    :coredumpsize=0:\
-    :tc=daemon:
-```
-
-These values are conservative defaults for small and medium deployments.
-Increase `openfiles-*` only if logs show descriptor exhaustion under load.
-
-Then rebuild database and assign class:
-
-```sh
-doas cap_mkdb /etc/login.conf
-#doas usermod -L telemt _telemt
-```
-
-Uncomment `usermod` if you want this class bound to the Telemt user.
-
-## 7. Functional smoke test
-
-1. Validate service state:
-
-```sh
-doas rcctl check telemt
-```
-
-2. Check listener is present (replace 443 if needed):
-
-```sh
-netstat -n -f inet -p tcp | grep LISTEN | grep '\.443'
-```
-
-3. Verify process user:
-
-```sh
-ps -o user,pid,command -ax | grep telemt | grep -v grep
-```
-
-4. If startup fails, debug in foreground:
-
-```sh
-RUST_LOG=debug /usr/local/bin/telemt /etc/telemt/config.toml
-```
-
-## 8. OpenBSD-specific caveats
-
-- OpenBSD does not support per-socket keepalive retries/interval tuning in the same way as Linux.
-- Telemt source already uses target-aware cfg gates for keepalive setup.
-- Use rc.d/rcctl, not systemd.

docs/QUICK_START_GUIDE.en.md

@@ -27,12 +27,12 @@ chmod +x /bin/telemt
 
 **0. Check port and generate secrets**
 
-The port you have selected for use should not be in the list:
+The port you have selected for use should be MISSING from the list, when:
 ```bash
 netstat -lnp
 ```
 
-Generate 16 bytes/32 characters in HEX format with OpenSSL or another way:
+Generate 16 bytes/32 characters HEX with OpenSSL or another way:
 ```bash
 openssl rand -hex 16
 ```
@@ -48,18 +48,13 @@ Save the obtained result somewhere. You will need it later!
 
 ---
 
-**1. Place your config to /etc/telemt/telemt.toml**
-
-Create the config directory:
-```bash
-mkdir /etc/telemt
-```
+**1. Place your config to /etc/telemt.toml**
 
 Open nano
 ```bash
-nano /etc/telemt/telemt.toml
+nano /etc/telemt.toml
 ```
-Insert your configuration:
+paste your config
 
 ```toml
 # === General Settings ===
@@ -72,9 +67,6 @@ classic = false
 secure = false
 tls = true
 
-[server]
-port = 443
-
 [server.api]
 enabled = true
 # listen = "127.0.0.1:9091"
@@ -94,70 +86,49 @@ then Ctrl+S -> Ctrl+X to save
 
 > [!WARNING]
 > Replace the value of the hello parameter with the value you obtained in step 0. 
-> Additionally, change the value of the tls_domain parameter to a different website.
-> Changing the tls_domain parameter will break all links that use the old domain!
+> Replace the value of the tls_domain parameter with another website.
 
 ---
 
-**2. Create telemt user**
-
-```bash
-useradd -d /opt/telemt -m -r -U telemt
-chown -R telemt:telemt /etc/telemt
-```
-
-**3. Create service in /etc/systemd/system/telemt.service**
+**2. Create service on /etc/systemd/system/telemt.service**
 
 Open nano
 ```bash
 nano /etc/systemd/system/telemt.service
 ```
 
-Insert this Systemd module:
+paste this Systemd Module
 ```bash
 [Unit]
 Description=Telemt
-After=network-online.target
-Wants=network-online.target
+After=network.target
 
 [Service]
 Type=simple
-User=telemt
-Group=telemt
-WorkingDirectory=/opt/telemt
-ExecStart=/bin/telemt /etc/telemt/telemt.toml
+WorkingDirectory=/bin
+ExecStart=/bin/telemt /etc/telemt.toml
 Restart=on-failure
 LimitNOFILE=65536
-AmbientCapabilities=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
-CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
-NoNewPrivileges=true
 
 [Install]
 WantedBy=multi-user.target
 ```
 then Ctrl+S -> Ctrl+X to save
 
-reload systemd units
-```bash
-systemctl daemon-reload
-```
 
-**4.** To start it, enter the command `systemctl start telemt`
+**3.** To start it, enter the command `systemctl start telemt`
 
-**5.** To get status information, enter `systemctl status telemt`
+**4.** To get status information, enter `systemctl status telemt`
 
-**6.** For automatic startup at system boot, enter `systemctl enable telemt`
+**5.** For automatic startup at system boot, enter `systemctl enable telemt`
 
-**7.** To get the link(s), enter:
+**6.** To get the link(s), enter
 ```bash
 curl -s http://127.0.0.1:9091/v1/users | jq
 ```
 
 > Any number of people can use one link.
 
-> [!WARNING]
-> Only the command from step 7 can provide a working link. Do not try to create it yourself or copy it from anywhere if you are not sure what you are doing!
-
 ---
 
 # Telemt via Docker Compose
@@ -185,8 +156,6 @@ docker compose down
 docker build -t telemt:local .
 docker run --name telemt --restart unless-stopped \
   -p 443:443 \
-  -p 9090:9090 \
-  -p 9091:9091 \
   -e RUST_LOG=info \
   -v "$PWD/config.toml:/app/config.toml:ro" \
   --read-only \

docs/QUICK_START_GUIDE.ru.md

@@ -48,16 +48,11 @@ python3 -c 'import os; print(os.urandom(16).hex())'
 
 ---
 
-**1. Поместите свою конфигурацию в файл /etc/telemt/telemt.toml**
-
-Создаём директорию для конфига:
-```bash
-mkdir /etc/telemt
-```
+**1. Поместите свою конфигурацию в файл /etc/telemt.toml**
 
 Открываем nano
 ```bash
-nano /etc/telemt/telemt.toml
+nano /etc/telemt.toml
 ```
 Вставьте свою конфигурацию
 
@@ -72,9 +67,6 @@ classic = false
 secure = false
 tls = true
 
-[server]
-port = 443
-
 [server.api]
 enabled = true
 # listen = "127.0.0.1:9091"
@@ -95,18 +87,10 @@ hello = "00000000000000000000000000000000"
 > [!WARNING]
 > Замените значение параметра hello на значение, которое вы получили в пункте 0.  
 > Так же замените значение параметра tls_domain на другой сайт.
-> Изменение параметра tls_domain сделает нерабочими все ссылки, использующие старый домен!
 
 ---
 
-**2. Создайте пользователя для telemt**
-
-```bash
-useradd -d /opt/telemt -m -r -U telemt
-chown -R telemt:telemt /etc/telemt
-```
-
-**3. Создайте службу в /etc/systemd/system/telemt.service**
+**2. Создайте службу в /etc/systemd/system/telemt.service**
 
 Открываем nano
 ```bash
@@ -117,45 +101,35 @@ nano /etc/systemd/system/telemt.service
 ```bash
 [Unit]
 Description=Telemt
-After=network-online.target
-Wants=network-online.target
+After=network.target
 
 [Service]
 Type=simple
-User=telemt
-Group=telemt
-WorkingDirectory=/opt/telemt
-ExecStart=/bin/telemt /etc/telemt/telemt.toml
+WorkingDirectory=/bin
+ExecStart=/bin/telemt /etc/telemt.toml
 Restart=on-failure
 LimitNOFILE=65536
-AmbientCapabilities=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
-CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
-NoNewPrivileges=true
 
 [Install]
 WantedBy=multi-user.target
 ```
 Затем нажмите Ctrl+S -> Ctrl+X, чтобы сохранить
 
-перезагрузите конфигурацию systemd
-```bash
-systemctl daemon-reload
-```
 
-**4.** Для запуска введите команду `systemctl start telemt`
+**3.** Для запуска введите команду `systemctl start telemt`
 
-**5.** Для получения информации о статусе введите `systemctl status telemt`
+**4.** Для получения информации о статусе введите `systemctl status telemt`
 
-**6.** Для автоматического запуска при запуске системы в введите `systemctl enable telemt`
+**5.** Для автоматического запуска при запуске системы в введите `systemctl enable telemt`
 
-**7.** Для получения ссылки/ссылок введите 
+**6.** Для получения ссылки/ссылок введите 
 ```bash
 curl -s http://127.0.0.1:9091/v1/users | jq
 ```
 > Одной ссылкой может пользоваться сколько угодно человек.
 
 > [!WARNING]
-> Рабочую ссылку может выдать только команда из 7 пункта. Не пытайтесь делать ее самостоятельно или копировать откуда-либо если вы не уверены в том, что делаете!
+> Рабочую ссылку может выдать только команда из 6 пункта. Не пытайтесь делать ее самостоятельно или копировать откуда-либо если вы не уверены в том, что делаете!
 
 ---
 
@@ -179,13 +153,11 @@ docker compose down
 > - По умолчанию публикуются порты 443:443, а контейнер запускается со сброшенными привилегиями (добавлена только `NET_BIND_SERVICE`)  
 > - Если вам действительно нужна сеть хоста (обычно это требуется только для некоторых конфигураций IPv6), раскомментируйте `network_mode: host`
 
-**Запуск без Docker Compose**
+**Запуск в Docker Compose**
 ```bash
 docker build -t telemt:local .
 docker run --name telemt --restart unless-stopped \
   -p 443:443 \
-  -p 9090:9090 \
-  -p 9091:9091 \
   -e RUST_LOG=info \
   -v "$PWD/config.toml:/app/config.toml:ro" \
   --read-only \

docs/TUNING.de.md

@@ -82,7 +82,7 @@ Die unten angegebenen `Default`-Werte sind Code-Defaults (bei fehlendem Schlüss
 
 | Feld | Gilt für | Typ | Pflicht | Default | Bedeutung |
 |---|---|---|---|---|---|
-| `[[upstreams]].type` | alle Upstreams | `"direct" \| "socks4" \| "socks5" \| "shadowsocks"` | ja | n/a | Upstream-Transporttyp. |
+| `[[upstreams]].type` | alle Upstreams | `"direct" \| "socks4" \| "socks5"` | ja | n/a | Upstream-Transporttyp. |
 | `[[upstreams]].weight` | alle Upstreams | `u16` | nein | `1` | Basisgewicht für weighted-random Auswahl. |
 | `[[upstreams]].enabled` | alle Upstreams | `bool` | nein | `true` | Deaktivierte Einträge werden beim Start ignoriert. |
 | `[[upstreams]].scopes` | alle Upstreams | `String` | nein | `""` | Komma-separierte Scope-Tags für Request-Routing. |
@@ -95,8 +95,6 @@ Die unten angegebenen `Default`-Werte sind Code-Defaults (bei fehlendem Schlüss
 | `interface` | `socks5` | `Option<String>` | nein | `null` | Wird nur genutzt, wenn `address` als `ip:port` angegeben ist. |
 | `username` | `socks5` | `Option<String>` | nein | `null` | SOCKS5 Benutzername. |
 | `password` | `socks5` | `Option<String>` | nein | `null` | SOCKS5 Passwort. |
-| `url` | `shadowsocks` | `String` | ja | n/a | Shadowsocks-SIP002-URL (`ss://...`). In Runtime-APIs wird nur `host:port` offengelegt. |
-| `interface` | `shadowsocks` | `Option<String>` | nein | `null` | Optionales ausgehendes Bind-Interface oder lokale Literal-IP. |
 
 ### Runtime-Regeln (wichtig)
 
@@ -117,7 +115,6 @@ Die unten angegebenen `Default`-Werte sind Code-Defaults (bei fehlendem Schlüss
 8. Im ME-Modus wird der gewählte Upstream auch für den ME-TCP-Dial-Pfad verwendet.
 9. Im ME-Modus ist bei `direct` mit bind/interface die STUN-Reflection bind-aware für KDF-Adressmaterial.
 10. Im ME-Modus werden bei SOCKS-Upstream `BND.ADDR/BND.PORT` für KDF verwendet, wenn gültig/öffentlich und gleiche IP-Familie.
-11. `shadowsocks`-Upstreams erfordern `general.use_middle_proxy = false`. Mit aktiviertem ME-Modus schlägt das Laden der Config sofort fehl.
 
 ## Upstream-Konfigurationsbeispiele
 
@@ -153,20 +150,7 @@ weight = 2
 enabled = true
 ```
 
-### Beispiel 4: Shadowsocks-Upstream
-
-```toml
-[general]
-use_middle_proxy = false
-
-[[upstreams]]
-type = "shadowsocks"
-url = "ss://2022-blake3-aes-256-gcm:BASE64_KEY@198.51.100.50:8388"
-weight = 2
-enabled = true
-```
-
-### Beispiel 5: Gemischte Upstreams mit Scopes
+### Beispiel 4: Gemischte Upstreams mit Scopes
 
 ```toml
 [[upstreams]]

docs/TUNING.en.md

@@ -82,7 +82,7 @@ Defaults below are code defaults (used when a key is omitted), not necessarily v
 
 | Field | Applies to | Type | Required | Default | Meaning |
 |---|---|---|---|---|---|
-| `[[upstreams]].type` | all upstreams | `"direct" \| "socks4" \| "socks5" \| "shadowsocks"` | yes | n/a | Upstream transport type. |
+| `[[upstreams]].type` | all upstreams | `"direct" \| "socks4" \| "socks5"` | yes | n/a | Upstream transport type. |
 | `[[upstreams]].weight` | all upstreams | `u16` | no | `1` | Base weight for weighted-random selection. |
 | `[[upstreams]].enabled` | all upstreams | `bool` | no | `true` | Disabled entries are ignored at startup. |
 | `[[upstreams]].scopes` | all upstreams | `String` | no | `""` | Comma-separated scope tags for request-level routing. |
@@ -95,8 +95,6 @@ Defaults below are code defaults (used when a key is omitted), not necessarily v
 | `interface` | `socks5` | `Option<String>` | no | `null` | Used only for SOCKS server `ip:port` dial path. |
 | `username` | `socks5` | `Option<String>` | no | `null` | SOCKS5 username auth. |
 | `password` | `socks5` | `Option<String>` | no | `null` | SOCKS5 password auth. |
-| `url` | `shadowsocks` | `String` | yes | n/a | Shadowsocks SIP002 URL (`ss://...`). Only `host:port` is exposed in runtime APIs. |
-| `interface` | `shadowsocks` | `Option<String>` | no | `null` | Optional outgoing bind interface or literal local IP. |
 
 ### Runtime rules (important)
 
@@ -117,7 +115,6 @@ Defaults below are code defaults (used when a key is omitted), not necessarily v
 8. In ME mode, the selected upstream is also used for ME TCP dial path.
 9. In ME mode for `direct` upstream with bind/interface, STUN reflection logic is bind-aware for KDF source material.
 10. In ME mode for SOCKS upstream, SOCKS `BND.ADDR/BND.PORT` is used for KDF when it is valid/public for the same family.
-11. `shadowsocks` upstreams require `general.use_middle_proxy = false`. Config load fails fast if ME mode is enabled.
 
 ## Upstream Configuration Examples
 
@@ -153,20 +150,7 @@ weight = 2
 enabled = true
 ```
 
-### Example 4: Shadowsocks upstream
-
-```toml
-[general]
-use_middle_proxy = false
-
-[[upstreams]]
-type = "shadowsocks"
-url = "ss://2022-blake3-aes-256-gcm:BASE64_KEY@198.51.100.50:8388"
-weight = 2
-enabled = true
-```
-
-### Example 5: Mixed upstreams with scopes
+### Example 4: Mixed upstreams with scopes
 
 ```toml
 [[upstreams]]

docs/TUNING.ru.md

@@ -82,7 +82,7 @@
 
 | Поле | Применимость | Тип | Обязательно | Default | Назначение |
 |---|---|---|---|---|---|
-| `[[upstreams]].type` | все upstream | `"direct" \| "socks4" \| "socks5" \| "shadowsocks"` | да | n/a | Тип upstream транспорта. |
+| `[[upstreams]].type` | все upstream | `"direct" \| "socks4" \| "socks5"` | да | n/a | Тип upstream транспорта. |
 | `[[upstreams]].weight` | все upstream | `u16` | нет | `1` | Базовый вес в weighted-random выборе. |
 | `[[upstreams]].enabled` | все upstream | `bool` | нет | `true` | Выключенные записи игнорируются на старте. |
 | `[[upstreams]].scopes` | все upstream | `String` | нет | `""` | Список scope-токенов через запятую для маршрутизации. |
@@ -95,8 +95,6 @@
 | `interface` | `socks5` | `Option<String>` | нет | `null` | Используется только если `address` задан как `ip:port`. |
 | `username` | `socks5` | `Option<String>` | нет | `null` | Логин SOCKS5 auth. |
 | `password` | `socks5` | `Option<String>` | нет | `null` | Пароль SOCKS5 auth. |
-| `url` | `shadowsocks` | `String` | да | n/a | Shadowsocks SIP002 URL (`ss://...`). В runtime API раскрывается только `host:port`. |
-| `interface` | `shadowsocks` | `Option<String>` | нет | `null` | Необязательный исходящий bind-интерфейс или literal локальный IP. |
 
 ### Runtime-правила
 
@@ -117,7 +115,6 @@
 8. В ME-режиме выбранный upstream также используется для ME TCP dial path.
 9. В ME-режиме для `direct` upstream с bind/interface STUN-рефлексия выполняется bind-aware для KDF материала.
 10. В ME-режиме для SOCKS upstream используются `BND.ADDR/BND.PORT` для KDF, если адрес валиден/публичен и соответствует IP family.
-11. `shadowsocks` upstream требует `general.use_middle_proxy = false`. При включенном ME-режиме конфиг отклоняется при загрузке.
 
 ## Примеры конфигурации Upstreams
 
@@ -153,20 +150,7 @@ weight = 2
 enabled = true
 ```
 
-### Пример 4: Shadowsocks upstream
-
-```toml
-[general]
-use_middle_proxy = false
-
-[[upstreams]]
-type = "shadowsocks"
-url = "ss://2022-blake3-aes-256-gcm:BASE64_KEY@198.51.100.50:8388"
-weight = 2
-enabled = true
-```
-
-### Пример 5: смешанные upstream с scopes
+### Пример 4: смешанные upstream с scopes
 
 ```toml
 [[upstreams]]

docs/VPS_DOUBLE_HOP.en.md

@@ -1,287 +0,0 @@
-<img src="https://gist.githubusercontent.com/avbor/1f8a128e628f47249aae6e058a57610b/raw/19013276c035e91058e0a9799ab145f8e70e3ff5/scheme.svg">
-
-## Concept
-- **Server A** (__conditionally Russian Federation_):\
-  Entry point, receives Telegram proxy user traffic via **HAProxy** (port `443`)\
-  and sends it to the tunnel to Server **B**.\
-  Internal IP in the tunnel — `10.10.10.2`\
-  Port for HAProxy clients — `443\tcp`
-- **Server B** (_conditionally Netherlands_):\
-  Exit point, runs **telemt** and accepts client connections through Server **A**.\
-  The server must have unrestricted access to Telegram servers.\
-  Internal IP in the tunnel — `10.10.10.1`\
-  AmneziaWG port — `8443\udp`\
-  Port for telemt clients — `443\tcp`
-
----
-
-## Step 1. Setting up the AmneziaWG tunnel (A <-> B)
-[AmneziaWG](https://github.com/amnezia-vpn/amneziawg-linux-kernel-module) must be installed on all servers.\
-All following commands are given for **Ubuntu 24.04**.\
-For RHEL-based distributions, installation instructions are available at the link above.
-
-### Installing AmneziaWG (Servers A and B)
-The following steps must be performed on each server:
-
-#### 1. Adding the AmneziaWG repository and installing required packages:
-```bash
-sudo apt install -y software-properties-common python3-launchpadlib gnupg2 linux-headers-$(uname -r) && \
-sudo add-apt-repository ppa:amnezia/ppa && \
-sudo apt-get install -y amneziawg
-```
-
-#### 2. Generating a unique key pair:
-```bash
-cd /etc/amnezia/amneziawg && \
-awg genkey | tee private.key | awg pubkey > public.key
-```
-
-As a result, you will get two files in the `/etc/amnezia/amneziawg` folder:\
-`private.key` - private, and\
-`public.key` - public server keys
-
-#### 3. Configuring network interfaces:
-Obfuscation parameters `S1`, `S2`, `H1`, `H2`, `H3`, `H4` must be strictly identical on both servers.\
-Parameters `Jc`, `Jmin` and `Jmax` can differ.\
-Parameters `I1-I5` ([Custom Protocol Signature](https://docs.amnezia.org/documentation/amnezia-wg/)) must be specified on the client side (Server **A**).
-
-Recommendations for choosing values:
-
-```text
-Jc — 1 ≤ Jc ≤ 128; from 4 to 12 inclusive
-Jmin — Jmax > Jmin < 1280*; recommended 8
-Jmax — Jmin < Jmax ≤ 1280*; recommended 80
-S1 — S1 ≤ 1132* (1280* - 148 = 1132); S1 + 56 ≠ S2;
-recommended range from 15 to 150 inclusive
-S2 — S2 ≤ 1188* (1280* - 92 = 1188);
-recommended range from 15 to 150 inclusive
-H1/H2/H3/H4 — must be unique and differ from each other;
-recommended range from 5 to 2147483647 inclusive
-
-* It is assumed that the Internet connection has an MTU of 1280.
-```
-
-> [!IMPORTANT]
-> It is recommended to use your own, unique values.\
-> You can use the [generator](https://htmlpreview.github.io/?https://gist.githubusercontent.com/avbor/955782b5c37b06240b243aa375baeac5/raw/13f5517ca473b47c412b9a99407066de973732bd/awg-gen.html) to select parameters.
-
-#### Server B Configuration (Netherlands):
-
-Create the interface configuration file (`awg0`)
-```bash
-nano /etc/amnezia/amneziawg/awg0.conf
-```
-
-File content
-```ini
-[Interface]
-Address = 10.10.10.1/24
-ListenPort = 8443
-PrivateKey = <PRIVATE_KEY_SERVER_B>
-SaveConfig = true
-Jc = 4
-Jmin = 8
-Jmax = 80
-S1 = 29
-S2 = 15
-S3 = 18
-S4 = 0
-H1 = 2087563914
-H2 = 188817757
-H3 = 101784570
-H4 = 432174303
-
-[Peer]
-PublicKey = <PUBLIC_KEY_SERVER_A>
-AllowedIPs = 10.10.10.2/32
-```
-`ListenPort` - the port on which the server will wait for connections, you can choose any free one.\
-`<PRIVATE_KEY_SERVER_B>` - the content of the `private.key` file from Server **B**.\
-`<PUBLIC_KEY_SERVER_A>` - the content of the `public.key` file from Server **A**.
-
-Open the port on the firewall (if enabled):
-```bash
-sudo ufw allow from <PUBLIC_IP_SERVER_A> to any port 8443 proto udp
-```
-
-`<PUBLIC_IP_SERVER_A>` - the external IP address of Server **A**.
-
-#### Server A Configuration (Russian Federation):
-Create the interface configuration file (awg0)
-
-```bash
-nano /etc/amnezia/amneziawg/awg0.conf
-```
-
-File content
-```ini
-[Interface]
-Address = 10.10.10.2/24
-PrivateKey = <PRIVATE_KEY_SERVER_A>
-Jc = 4
-Jmin = 8
-Jmax = 80
-S1 = 29
-S2 = 15
-S3 = 18
-S4 = 0
-H1 = 2087563914
-H2 = 188817757
-H3 = 101784570
-H4 = 432174303
-I1 = <b 0xc10000000108981eba846e21f74e00>
-I2 = <b 0xc20000000108981eba846e21f74e00>
-I3 = <b 0xc30000000108981eba846e21f74e00>
-I4 = <b 0x43981eba846e21f74e>
-I5 = <b 0x43981eba846e21f74e>
-
-[Peer]
-PublicKey = <PUBLIC_KEY_SERVER_B>
-Endpoint = <PUBLIC_IP_SERVER_B>:8443
-AllowedIPs = 10.10.10.1/32
-PersistentKeepalive = 25
-```
-
-`<PRIVATE_KEY_SERVER_A>` - the content of the `private.key` file from Server **A**.\
-`<PUBLIC_KEY_SERVER_B>` - the content of the `public.key` file from Server **B**.\
-`<PUBLIC_IP_SERVER_B>` - the public IP address of Server **B**.
-
-Enable the tunnel on both servers:
-```bash
-sudo systemctl enable --now awg-quick@awg0
-```
-
-Make sure Server B is accessible from Server A through the tunnel.
-```bash
-ping 10.10.10.1
-PING 10.10.10.1 (10.10.10.1) 56(84) bytes of data.
-64 bytes from 10.10.10.1: icmp_seq=1 ttl=64 time=35.1 ms
-64 bytes from 10.10.10.1: icmp_seq=2 ttl=64 time=35.0 ms
-64 bytes from 10.10.10.1: icmp_seq=3 ttl=64 time=35.1 ms
-^C
-```
----
-
-## Step 2. Installing telemt on Server B (conditionally Netherlands)
-Installation and configuration are described [here](https://github.com/telemt/telemt/blob/main/docs/QUICK_START_GUIDE.ru.md) or [here](https://gitlab.com/An0nX/telemt-docker#-quick-start-docker-compose).\
-It is assumed that telemt expects connections on port `443\tcp`.
-
-In the telemt config, you must enable the `Proxy` protocol and restrict connections to it only through the tunnel.
-```toml
-[server]
-port = 443
-listen_addr_ipv4 = "10.10.10.1"
-proxy_protocol = true
-```
-
-Also, for correct link generation, specify the FQDN or IP address and port of Server `A`
-```toml
-[general.links]
-show = "*"
-public_host = "<FQDN_OR_IP_SERVER_A>"
-public_port = 443
-```
-
-Open the port on the firewall (if enabled):
-```bash
-sudo ufw allow from 10.10.10.2 to any port 443 proto tcp
-```
-
----
-
-## Step 3. Configuring HAProxy on Server A (Russian Federation)
-Since the version in the standard Ubuntu repository is relatively old, it makes sense to use the official Docker image.\
-[Instructions](https://docs.docker.com/engine/install/ubuntu/) for installing Docker on Ubuntu.
-
-> [!WARNING]
-> By default, regular users do not have rights to use ports < 1024.
-> Attempts to run HAProxy on port 443 can lead to errors:
-> ```
-> [ALERT] (8) : Binding [/usr/local/etc/haproxy/haproxy.cfg:17] for frontend tcp_in_443: 
-> protocol tcpv4: cannot bind socket (Permission denied) for [0.0.0.0:443].
-> ```
-> There are two simple ways to bypass this restriction, choose one:
-> 1. At the OS level, change the net.ipv4.ip_unprivileged_port_start setting to allow users to use all ports:
-> ```
-> echo "net.ipv4.ip_unprivileged_port_start = 0" | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
-> ```
-> or
-> 
-> 2. Run HAProxy as root:
-> Uncomment the `user: "root"` parameter in docker-compose.yaml.
-
-#### Create a folder for HAProxy:
-```bash
-mkdir -p /opt/docker-compose/haproxy && cd $_
-```
-
-#### Create the docker-compose.yaml file
-`nano docker-compose.yaml`
-
-File content
-```yaml
-services:
-  haproxy:
-    image: haproxy:latest
-    container_name: haproxy
-    restart: unless-stopped
-    # user: "root"
-    network_mode: "host"
-    volumes:
-      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
-    logging:
-      driver: "json-file"
-      options:
-        max-size: "1m"
-        max-file: "1"
-```
-
-#### Create the haproxy.cfg config file
-Accept connections on port 443\tcp and send them through the tunnel to Server `B` 10.10.10.1:443
-
-`nano haproxy.cfg`
-
-File content
-
-```haproxy
-global
-    log stdout format raw local0
-    maxconn 10000
-
-defaults
-    log     global
-    mode    tcp
-    option  tcplog
-    option  clitcpka
-    option  srvtcpka
-    timeout connect 5s
-    timeout client  2h
-    timeout server  2h
-    timeout check   5s
-
-frontend tcp_in_443
-    bind *:443
-    maxconn 8000
-    option tcp-smart-accept
-    default_backend telemt_nodes
-
-backend telemt_nodes
-    option tcp-smart-connect
-    server server_a 10.10.10.1:443 check inter 5s rise 2 fall 3 send-proxy-v2
-
-
-```
-> [!WARNING]
-> **The file must end with an empty line, otherwise HAProxy will not start!**
-
-#### Allow port 443\tcp in the firewall (if enabled)
-```bash
-sudo ufw allow 443/tcp
-```
-
-#### Start the HAProxy container
-```bash
-docker compose up -d
-```
-
-If everything is configured correctly, you can now try connecting Telegram clients using links from the telemt log\api.

docs/VPS_DOUBLE_HOP.ru.md

@@ -1,291 +0,0 @@
-<img src="https://gist.githubusercontent.com/avbor/1f8a128e628f47249aae6e058a57610b/raw/19013276c035e91058e0a9799ab145f8e70e3ff5/scheme.svg">
-
-## Концепция
-- **Сервер A** (_РФ_):\
-  Точка входа, принимает трафик пользователей Telegram-прокси через **HAProxy** (порт `443`)\
-  и отправляет в туннель на Сервер **B**.\
-  Внутренний IP в туннеле — `10.10.10.2`\
-  Порт для клиентов HAProxy — `443\tcp`
-- **Сервер B** (_условно Нидерланды_):\
-  Точка выхода, на нем работает **telemt** и принимает подключения клиентов через Сервер **A**.\
-  На сервере должен быть неограниченный доступ до серверов Telegram.\
-  Внутренний IP в туннеле — `10.10.10.1`\
-  Порт AmneziaWG — `8443\udp`\
-  Порт для клиентов telemt — `443\tcp`
-
----
-
-## Шаг 1. Настройка туннеля AmneziaWG (A <-> B)
-
-На всех серверах необходимо установить [amneziawg](https://github.com/amnezia-vpn/amneziawg-linux-kernel-module).\
-Далее все команды даны для **Ununtu 24.04**.\
-Для RHEL-based дистрибутивов инструкция по установке есть по ссылке выше.
-
-### Установка AmneziaWG (Сервера A и B)
-На каждом из серверов необходимо выполнить следующие шаги:
-
-#### 1. Добавление репозитория AmneziaWG и установка необходимых пакетов:
-```bash
-sudo apt install -y software-properties-common python3-launchpadlib gnupg2 linux-headers-$(uname -r) && \
-sudo add-apt-repository ppa:amnezia/ppa && \
-sudo apt-get install -y amneziawg
-```
- 
-#### 2. Генерация уникальной пары ключей:
-```bash
-cd /etc/amnezia/amneziawg && \
-awg genkey | tee private.key | awg pubkey > public.key
-```
-В результате вы получите в папке `/etc/amnezia/amneziawg` два файла:\
-`private.key` - приватный и\
-`public.key` - публичный ключи сервера
-
-#### 3. Настройка сетевых интерфейсов:
-
-Параметры обфускации `S1`, `S2`, `H1`, `H2`, `H3`, `H4` должны быть строго идентичными на обоих серверах.\
-Параметры `Jc`, `Jmin` и `Jmax` могут отличатся.\
-Параметры `I1-I5` ([Custom Protocol Signature](https://docs.amnezia.org/documentation/amnezia-wg/)) нужно указывать на стороне _клиента_ (Сервер **А**).
-
-Рекомендации по выбору значений:
-```text
-Jc — 1 ≤ Jc ≤ 128; от 4 до 12 включительно
-Jmin — Jmax > Jmin < 1280*; рекомендовано 8
-Jmax — Jmin < Jmax ≤ 1280*; рекомендовано 80
-S1 — S1 ≤ 1132* (1280* - 148 = 1132); S1 + 56 ≠ S2;
-рекомендованный диапазон от 15 до 150 включительно
-S2 — S2 ≤ 1188* (1280* - 92 = 1188);
-рекомендованный диапазон от 15 до 150 включительно
-H1/H2/H3/H4 — должны быть уникальны и отличаться друг от друга;
-рекомендованный диапазон от 5 до 2147483647 включительно
-
-* Предполагается, что подключение к Интернету имеет MTU 1280.
-```
-> [!IMPORTANT]
-> Рекомендуется использовать собственные, уникальные значения.\
-> Для выбора параметров можете воспользоваться [генератором](https://htmlpreview.github.io/?https://gist.githubusercontent.com/avbor/955782b5c37b06240b243aa375baeac5/raw/13f5517ca473b47c412b9a99407066de973732bd/awg-gen.html).
-
-#### Конфигурация Сервера B (_Нидерланды_):
-
-Создаем файл конфигурации интерфейса (`awg0`)
-```bash
-nano /etc/amnezia/amneziawg/awg0.conf
-```
-
-Содержимое файла
-```ini
-[Interface]
-Address = 10.10.10.1/24
-ListenPort = 8443
-PrivateKey = <PRIVATE_KEY_SERVER_B>
-SaveConfig = true
-Jc = 4
-Jmin = 8
-Jmax = 80
-S1 = 29
-S2 = 15
-S3 = 18
-S4 = 0
-H1 = 2087563914
-H2 = 188817757
-H3 = 101784570
-H4 = 432174303
-
-[Peer]
-PublicKey = <PUBLIC_KEY_SERVER_A>
-AllowedIPs = 10.10.10.2/32
-```
-
-`ListenPort` - порт, на котором сервер будет ждать подключения, можете выбрать любой свободный.\
-`<PRIVATE_KEY_SERVER_B>` - содержимое файла `private.key` с сервера **B**.\
-`<PUBLIC_KEY_SERVER_A>` - содержимое файла `public.key` с сервера **A**.
-
-Открываем порт на фаерволе (если включен):
-```bash
-sudo ufw allow from <PUBLIC_IP_SERVER_A> to any port 8443 proto udp
-```
-
-`<PUBLIC_IP_SERVER_A>` - внешний IP адрес Сервера **A**.
-
-#### Конфигурация Сервера A (_РФ_):
-
-Создаем файл конфигурации интерфейса (`awg0`)
-```bash
-nano /etc/amnezia/amneziawg/awg0.conf
-```
-
-Содержимое файла
-```ini
-[Interface]
-Address = 10.10.10.2/24
-PrivateKey = <PRIVATE_KEY_SERVER_A>
-Jc = 4
-Jmin = 8
-Jmax = 80
-S1 = 29
-S2 = 15
-S3 = 18
-S4 = 0
-H1 = 2087563914
-H2 = 188817757
-H3 = 101784570
-H4 = 432174303
-I1 = <b 0xc10000000108981eba846e21f74e00>
-I2 = <b 0xc20000000108981eba846e21f74e00>
-I3 = <b 0xc30000000108981eba846e21f74e00>
-I4 = <b 0x43981eba846e21f74e>
-I5 = <b 0x43981eba846e21f74e>
-
-[Peer]
-PublicKey = <PUBLIC_KEY_SERVER_B>
-Endpoint = <PUBLIC_IP_SERVER_B>:8443
-AllowedIPs = 10.10.10.1/32
-PersistentKeepalive = 25
-```
-
-`<PRIVATE_KEY_SERVER_A>` - содержимое файла `private.key` с сервера **A**.\
-`<PUBLIC_KEY_SERVER_B>` - содержимое файла `public.key` с сервера **B**.\
-`<PUBLIC_IP_SERVER_B>` - публичный IP адресс сервера **B**.
-
-#### Включаем туннель на обоих серверах:
-```bash
-sudo systemctl enable --now awg-quick@awg0 
-```
-
-Убедитесь, что с Сервера `A` доступен Сервер `B` через туннель.
-```bash
-ping 10.10.10.1
-PING 10.10.10.1 (10.10.10.1) 56(84) bytes of data.
-64 bytes from 10.10.10.1: icmp_seq=1 ttl=64 time=35.1 ms
-64 bytes from 10.10.10.1: icmp_seq=2 ttl=64 time=35.0 ms
-64 bytes from 10.10.10.1: icmp_seq=3 ttl=64 time=35.1 ms
-^C
-
-```
-
----
-
-## Шаг 2. Установка telemt на Сервере B (_условно Нидерланды_)
-
-Установка и настройка описаны [здесь](https://github.com/telemt/telemt/blob/main/docs/QUICK_START_GUIDE.ru.md) или [здесь](https://gitlab.com/An0nX/telemt-docker#-quick-start-docker-compose).\
-Подразумевается что telemt ожидает подключения на порту `443\tcp`.
-
-В конфиге telemt необходимо включить протокол `Proxy` и ограничить подключения к нему только через туннель.
-
-```toml
-[server]
-port = 443
-listen_addr_ipv4 = "10.10.10.1"
-proxy_protocol = true
-```
-
-А также, для правильной генерации ссылок, указать FQDN или IP адрес и порт Сервера `A` 
-
-```toml
-[general.links]
-show = "*"
-public_host = "<FQDN_OR_IP_SERVER_A>"
-public_port = 443
-```
-
-Открываем порт на фаерволе (если включен):
-```bash
-sudo ufw allow from 10.10.10.2 to any port 443 proto tcp
-```
-
----
-
-### Шаг 3. Настройка HAProxy на Сервере A (_РФ_)
-
-Т.к. в стандартном репозитории Ubuntu версия относительно старая, имеет смысл воспользоваться официальным образом Docker.\
-[Инструкция](https://docs.docker.com/engine/install/ubuntu/) по установке Docker на Ubuntu.
-
-> [!WARNING]
-> По умолчанию у обычных пользователей нет прав на использование портов < 1024.\
-> Попытки запустить HAProxy на 443 порту могут приводить к ошибкам:
-> ```
-> [ALERT] (8) : Binding [/usr/local/etc/haproxy/haproxy.cfg:17] for frontend tcp_in_443: 
-> protocol tcpv4: cannot bind socket (Permission denied) for [0.0.0.0:443].
-> ```
-> Есть два простых способа обойти это ограничение, выберите что-то одно:
-> 1. На уровне ОС изменить настройку net.ipv4.ip_unprivileged_port_start, разрешив пользователям использовать все порты:
-> ```
-> echo "net.ipv4.ip_unprivileged_port_start = 0" | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
-> ```
-> или
-> 
-> 2. Запустить HAProxy под root:\
-> Раскомментируйте в docker-compose.yaml параметр `user: "root"`.
-
-#### Создаем папку для HAProxy:
-```bash
-mkdir -p /opt/docker-compose/haproxy && cd $_
-```
-#### Создаем файл docker-compose.yaml
-
-`nano docker-compose.yaml`
-
-Содержимое файла
-```yaml
-services:
-  haproxy:
-    image: haproxy:latest
-    container_name: haproxy
-    restart: unless-stopped
-    # user: "root"
-    network_mode: "host"
-    volumes:
-      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
-    logging:
-      driver: "json-file"
-      options:
-        max-size: "1m"
-        max-file: "1"
-```
-#### Создаем файл конфига haproxy.cfg
-Принимаем подключения на порту 443\tcp и отправляем их через туннель на Сервер `B` 10.10.10.1:443
-
-`nano haproxy.cfg`
-
-Содержимое файла
-```haproxy
-global
-    log stdout format raw local0
-    maxconn 10000
-
-defaults
-    log     global
-    mode    tcp
-    option  tcplog
-    option  clitcpka
-    option  srvtcpka
-    timeout connect 5s
-    timeout client  2h
-    timeout server  2h
-    timeout check   5s
-
-frontend tcp_in_443
-    bind *:443
-    maxconn 8000
-    option tcp-smart-accept
-    default_backend telemt_nodes
-
-backend telemt_nodes
-    option tcp-smart-connect
-    server server_a 10.10.10.1:443 check inter 5s rise 2 fall 3 send-proxy-v2
-
-
-```
->[!WARNING]
->**Файл должен заканчиваться пустой строкой, иначе HAProxy не запустится!**
-
-#### Разрешаем порт 443\tcp в фаерволе (если включен)
-```bash
-sudo ufw allow 443/tcp
-```
-
-#### Запускаем контейнер HAProxy
-```bash
-docker compose up -d
-```
-
-Если все настроено верно, то теперь можно пробовать подключить клиентов Telegram с использованием ссылок из лога\api telemt.

docs/fronting-splitting/TLS-F-TCP-S.ru.md

@@ -1,278 +0,0 @@
-# TLS-F и TCP-S в Telemt
-
-## Общая архитектура
-
-**Telemt** - это прежде всего реализация **MTProxy**, через которую проходит payload Telegram
-
-Подсистема **TLS-Fronting / TCP-Splitting** служит **маскировочным транспортным слоем**, задача которого - сделать MTProxy-соединение внешне похожим на обычное TLS-подключение к легитимному сайту
-
-Таким образом:
-
-- **MTProxy** - основной функциональный слой Telemt для обработки Telegram-трафика
-- **TLS-Fronting / TCP-Splitting** - подсистема маскировки транспорта
-
-С точки зрения сети Telemt ведёт себя как **TLS-сервер**, но фактически:
-
-- валидные MTProxy-клиенты остаются внутри контура Telemt
-- любые другие TLS-клиенты проксируются на обычный HTTPS-сервер-заглушку
-
-# Базовый сценарий / Best-practice
-
-Предположим, у вас есть домен:
-
-```
-umweltschutz.de
-```
-
-### 1 DNS
-
-Вы создаёте A-запись:
-
-```
-umweltschutz.de -> A-запись 198.18.88.88
-```
-
-где `198.18.88.88` - IP вашего сервера с telemt
-
-### 2 TLS-домен
-
-В конфигурации Telemt:
-
-```toml
-[censorship]
-tls_domain = "umweltschutz.de"
-```
-
-Этот домен используется клиентом как SNI в ClientHello
-
-### 3 Сервер-заглушка
-
-Вы поднимаете обычный HTTPS-сервер, например **nginx**, с сертификатом для этого домена.
-
-Он может работать:
-
-- на том же сервере
-- на другом сервере
-- на другом порту
-
-В конфигурации Telemt:
-
-```toml
-[censorship]
-mask_host = "127.0.0.1"
-mask_port = 8443
-```
-
-где `127.0.0.1` - IP сервера-заглушки, а 8443 - порт, который он слушает
-
-Этот сервер нужен **для обработки любых non-MTProxy запросов**
-
-### 4 Работа Telemt
-
-После запуска Telemt действует следующим образом:
-
-1) принимает входящее TCP-соединение
-2) анализирует TLS-ClientHello
-3) пытается определить, является ли соединение валидным **MTProxy FakeTLS**
-
-Далее работают два варианта логики:
-
----
-
-# Сценарий 1 - MTProxy клиент с валидным ключом
-
-Если клиент предъявил **валидный MTProxy-ключ**:
-
-- соединение **остаётся внутри Telemt**
-- TLS используется только как **транспортная маскировка**
-- далее запускается обычная логика **MTProxy**
-
-Для внешнего наблюдателя это выглядит как:
-
-```
-TLS connection -> umweltschutz.de
-```
-
-Хотя внутри передаётся **MTProto-трафик Telegram**
-
-# Сценарий 2 - обычный TLS-клиент - crawler / scanner / browser
-
-Если Telemt не обнаруживает валидный MTProxy-ключ:
-
-соединение **переключается в режим TCP-Splitting / TCP-Splicing**.
-
-В этом режиме Telemt:
-
-1. открывает новое TCP-соединение к
-
-```
-mask_host:mask_port
-```
-
-2. начинает **проксировать TCP-трафик**
-
-Важно:
-
-* клиентский TLS-запрос **НЕ модифицируется**
-* **ClientHello передаётся "как есть", без изменений**
-* **SNI остаётся неизменным**
-* Telemt **не завершает TLS-рукопожатие**, а только перенаправляет его на более низком уровне сетевого стека - L4
-
-Таким образом upstream-сервер получает **оригинальное TLS-соединение клиента**:
-
-- если это nginx-заглушка, он просто отдаёт обычный сайт
-- для внешнего наблюдателя это выглядит как обычный HTTPS-сервер
-
-# TCP-S / TCP-Splitting / TCP-Splicing
-
-Ключевые свойства механизма:
-
-**Telemt работает как TCP-переключатель:**
-
-1) принимает соединение
-2️) определяет тип клиента
-3) либо:
-
-- обрабатывает MTProxy внутри
-- либо проксирует TCP-поток
-
-При проксировании:
-
-- Telemt **разрешает `mask_host` в IP**
-- устанавливает TCP-соединение
-- начинает **bidirectional TCP relay**
-
-При этом:
-
-- TLS-рукопожатие происходит **между клиентом и `mask_host`**
-- Telemt выступает только **на уровне L4 - как TCP-релей**, такой же как HAProxy в TCP-режиме
-
-# Использование чужого домена
-
-Можно использовать и внешний сайт.
-
-Например:
-
-```toml
-[censorship]
-tls_domain = "github.com"
-mask_host = "github.com"
-mask_port = 443
-```
-
-или
-
-```toml
-[censorship]
-mask_host = "140.82.121.4"
-```
-
-В этом случае:
-
-- цензор видит **TLS-подключение к github.com**
-- обычные клиенты/краулер действительно получают **настоящий GitHub**
-
-Telemt просто **проксирует TCP-соединение на GitHub**
-
-# Что видит анализатор трафика?
-
-Для DPI это выглядит так:
-
-```
-client -> TLS -> github.com
-```
-
-или
-
-```
-client -> TLS -> umweltschutz.de
-```
-
-TLS-handshake выглядит валидным, SNI соответствует домену, сертификат корректный - от целевого `mask_host:mask_port`
-
-# Что видит сканер / краулер?
-
-Если сканер попытается подключиться:
-
-```
-openssl s_client -connect 198.18.88.88:443 -servername umweltschutz.de
-```
-
-он получит **обычный HTTPS-сайт-заглушку**
-
-Потому что:
-
-- он не предъявил MTProxy-ключ
-- Telemt отправил соединение на `mask_host:mask_port`, на котором находится nginx 
-
-# Какую проблему решает TLS-Fronting / TCP-Splitting?
-
-Эта архитектура решает сразу несколько проблем обхода цензуры.
-
-## 1 Закрытие плоскости MTProxy от активного сканирования
-
-Многие цензоры:
-
-- сканируют IP-адреса
-- проверяют известные сигнатуры прокси
-
-Telemt отвечает на такие проверки **обычным HTTPS-сайтом**, поэтому прокси невозможно обнаружить простым сканированием
-
----
-
-## 2 Маскировка трафика под легитимный TLS
-
-Для DPI-систем соединение выглядит как:
-
-```
-обычный TLS-трафик к популярному домену
-```
-
-Это делает блокировку значительно сложнее и непредсказуемее
-
----
-
-## 3 Устойчивость к протокольному анализу
-
-MTProxy трафик проходит **внутри TLS-like-потока**, поэтому:
-
-- не видны характерные сигнатуры MTProto
-- соединение выглядит как обычный HTTPS
-
----
-
-## 4 Правдоподобное поведение сервера
-
-Даже если краулер:
-
-- подключится сам
-- выполнит TLS-handshake
-- попытается получить HTTP-ответ
-
-он увидит **реальный сайт**, а не telemt
-
-Это устраняет один из главных признаков для антифрод-краулеров мобильных операторов
-
-# Схема
-
-```text
-			Client
-			  │
-			  │ TCP
-			  │
-			  V
-			Telemt
-			  │
-			  ├── valid MTProxy key
-			  │        │
-			  │        V
-			  │     MTProxy logic
-			  │
-			  └── обычный TLS клиент
-			  │
-			  V
-		 TCP-Splitting
-			  │
-			  V
-	  mask_host:mask_port
-```

install.sh

@@ -3,717 +3,91 @@ set -eu
 
 REPO="${REPO:-telemt/telemt}"
 BIN_NAME="${BIN_NAME:-telemt}"
-INSTALL_DIR="${INSTALL_DIR:-/bin}"
-CONFIG_DIR="${CONFIG_DIR:-/etc/telemt}"
-CONFIG_FILE="${CONFIG_FILE:-${CONFIG_DIR}/telemt.toml}"
-WORK_DIR="${WORK_DIR:-/opt/telemt}"
-TLS_DOMAIN="${TLS_DOMAIN:-petrovich.ru}"
-SERVER_PORT="${SERVER_PORT:-443}"
-USER_SECRET=""
-AD_TAG=""
-SERVICE_NAME="telemt"
-TEMP_DIR=""
-SUDO=""
-CONFIG_PARENT_DIR=""
-SERVICE_START_FAILED=0
-
-PORT_PROVIDED=0
-SECRET_PROVIDED=0
-AD_TAG_PROVIDED=0
-DOMAIN_PROVIDED=0
-
-ACTION="install"
-TARGET_VERSION="${VERSION:-latest}"
-
-while [ $# -gt 0 ]; do
-    case "$1" in
-        -h|--help) ACTION="help"; shift ;;
-        -d|--domain)
-            if [ "$#" -lt 2 ] || [ -z "$2" ]; then
-                printf '[ERROR] %s requires a domain argument.\n' "$1" >&2
-                exit 1
-            fi
-            TLS_DOMAIN="$2"; DOMAIN_PROVIDED=1; shift 2 ;;
-        -p|--port)
-            if [ "$#" -lt 2 ] || [ -z "$2" ]; then
-                printf '[ERROR] %s requires a port argument.\n' "$1" >&2; exit 1
-            fi
-            case "$2" in
-                *[!0-9]*) printf '[ERROR] Port must be a valid number.\n' >&2; exit 1 ;;
-            esac
-            port_num="$(printf '%s\n' "$2" | sed 's/^0*//')"
-            [ -z "$port_num" ] && port_num="0"
-            if [ "${#port_num}" -gt 5 ] || [ "$port_num" -lt 1 ] || [ "$port_num" -gt 65535 ]; then
-                printf '[ERROR] Port must be between 1 and 65535.\n' >&2; exit 1
-            fi
-            SERVER_PORT="$port_num"; PORT_PROVIDED=1; shift 2 ;;
-        -s|--secret)
-            if [ "$#" -lt 2 ] || [ -z "$2" ]; then
-                printf '[ERROR] %s requires a secret argument.\n' "$1" >&2; exit 1
-            fi
-            case "$2" in
-                *[!0-9a-fA-F]*)
-                    printf '[ERROR] Secret must contain only hex characters.\n' >&2; exit 1 ;;
-            esac
-            if [ "${#2}" -ne 32 ]; then
-                printf '[ERROR] Secret must be exactly 32 chars.\n' >&2; exit 1
-            fi
-            USER_SECRET="$2"; SECRET_PROVIDED=1; shift 2 ;;
-        -a|--ad-tag|--ad_tag)
-            if [ "$#" -lt 2 ] || [ -z "$2" ]; then
-                printf '[ERROR] %s requires an ad_tag argument.\n' "$1" >&2; exit 1
-            fi
-            AD_TAG="$2"; AD_TAG_PROVIDED=1; shift 2 ;;
-        uninstall|--uninstall)
-            if [ "$ACTION" != "purge" ]; then ACTION="uninstall"; fi
-            shift ;;
-        purge|--purge) ACTION="purge"; shift ;;
-        install|--install) ACTION="install"; shift ;;
-        -*) printf '[ERROR] Unknown option: %s\n' "$1" >&2; exit 1 ;;
-        *)
-            if [ "$ACTION" = "install" ]; then TARGET_VERSION="$1"
-            else printf '[WARNING] Ignoring extra argument: %s\n' "$1" >&2; fi
-            shift ;;
-    esac
-done
+VERSION="${1:-${VERSION:-latest}}"
+INSTALL_DIR="${INSTALL_DIR:-/usr/local/bin}"
 
 say() {
-    if [ "$#" -eq 0 ] || [ -z "${1:-}" ]; then
-        printf '\n'
-    else
-        printf '[INFO] %s\n' "$*"
-    fi
-}
-die() { printf '[ERROR] %s\n' "$*" >&2; exit 1; }
-
-write_root() { $SUDO sh -c 'cat > "$1"' _ "$1"; }
-
-cleanup() {
-    if [ -n "${TEMP_DIR:-}" ] && [ -d "$TEMP_DIR" ]; then
-        rm -rf -- "$TEMP_DIR"
-    fi
-}
-trap cleanup EXIT INT TERM
-
-show_help() {
-    say "Usage: $0 [ <version> | install | uninstall | purge ] [ options ]"
-    say "  <version>    Install specific version (e.g. 3.3.15, default: latest)"
-    say "  install      Install the latest version"
-    say "  uninstall    Remove the binary and service"
-    say "  purge        Remove everything including configuration, data, and user"
-    say ""
-    say "Options:"
-    say "  -d, --domain Set TLS domain (default: petrovich.ru)"
-    say "  -p, --port   Set server port (default: 443)"
-    say "  -s, --secret Set specific user secret (32 hex characters)"
-    say "  -a, --ad-tag Set ad_tag"
-    exit 0
+    printf '%s\n' "$*"
 }
 
-check_os_entity() {
-    if command -v getent >/dev/null 2>&1; then getent "$1" "$2" >/dev/null 2>&1
-    else grep -q "^${2}:" "/etc/$1" 2>/dev/null; fi
+die() {
+    printf 'Error: %s\n' "$*" >&2
+    exit 1
 }
 
-normalize_path() {
-    printf '%s\n' "$1" | tr -s '/' | sed 's|/$||; s|^$|/|'
-}
-
-get_realpath() {
-    path_in="$1"
-    case "$path_in" in /*) ;; *) path_in="$(pwd)/$path_in" ;; esac
-
-    if command -v realpath >/dev/null 2>&1; then
-        if realpath_out="$(realpath -m "$path_in" 2>/dev/null)"; then
-            printf '%s\n' "$realpath_out"
-            return
-        fi
-    fi
-
-    if command -v readlink >/dev/null 2>&1; then
-        resolved_path="$(readlink -f "$path_in" 2>/dev/null || true)"
-        if [ -n "$resolved_path" ]; then
-            printf '%s\n' "$resolved_path"
-            return
-        fi
-    fi
-
-    d="${path_in%/*}"; b="${path_in##*/}"
-    if [ -z "$d" ]; then d="/"; fi
-    if [ "$d" = "$path_in" ]; then d="/"; b="$path_in"; fi
-
-    if [ -d "$d" ]; then
-        abs_d="$(cd "$d" >/dev/null 2>&1 && pwd || true)"
-        if [ -n "$abs_d" ]; then
-            if [ "$b" = "." ] || [ -z "$b" ]; then printf '%s\n' "$abs_d"
-            elif [ "$abs_d" = "/" ]; then printf '/%s\n' "$b"
-            else printf '%s/%s\n' "$abs_d" "$b"; fi
-        else
-            normalize_path "$path_in"
-        fi
-    else
-        normalize_path "$path_in"
-    fi
-}
-
-get_svc_mgr() {
-    if command -v systemctl >/dev/null 2>&1 && [ -d /run/systemd/system ]; then echo "systemd"
-    elif command -v rc-service >/dev/null 2>&1; then echo "openrc"
-    else echo "none"; fi
-}
-
-is_config_exists() {
-    if [ -n "$SUDO" ]; then
-        $SUDO sh -c '[ -f "$1" ]' _ "$CONFIG_FILE"
-    else
-        [ -f "$CONFIG_FILE" ]
-    fi
-}
-
-verify_common() {
-    [ -n "$BIN_NAME" ] || die "BIN_NAME cannot be empty."
-    [ -n "$INSTALL_DIR" ] || die "INSTALL_DIR cannot be empty."
-    [ -n "$CONFIG_DIR" ] || die "CONFIG_DIR cannot be empty."
-    [ -n "$CONFIG_FILE" ] || die "CONFIG_FILE cannot be empty."
-
-    case "${INSTALL_DIR}${CONFIG_DIR}${WORK_DIR}${CONFIG_FILE}" in
-        *[!a-zA-Z0-9_./-]*) die "Invalid characters in paths." ;;
-    esac
-
-    case "$TARGET_VERSION" in *[!a-zA-Z0-9_.-]*) die "Invalid characters in version." ;; esac
-    case "$BIN_NAME" in *[!a-zA-Z0-9_-]*) die "Invalid characters in BIN_NAME." ;; esac
-
-    INSTALL_DIR="$(get_realpath "$INSTALL_DIR")"
-    CONFIG_DIR="$(get_realpath "$CONFIG_DIR")"
-    WORK_DIR="$(get_realpath "$WORK_DIR")"
-    CONFIG_FILE="$(get_realpath "$CONFIG_FILE")"
-
-    CONFIG_PARENT_DIR="${CONFIG_FILE%/*}"
-    if [ -z "$CONFIG_PARENT_DIR" ]; then CONFIG_PARENT_DIR="/"; fi
-    if [ "$CONFIG_PARENT_DIR" = "$CONFIG_FILE" ]; then CONFIG_PARENT_DIR="."; fi
-
-    if [ "$(id -u)" -eq 0 ]; then
-        SUDO=""
-    else
-        command -v sudo >/dev/null 2>&1 || die "This script requires root or sudo."
-        SUDO="sudo"
-        if ! sudo -n true 2>/dev/null; then
-            if ! [ -t 0 ]; then
-                die "sudo requires a password, but no TTY detected."
-            fi
-        fi
-    fi
-
-    if [ -n "$SUDO" ]; then
-        if $SUDO sh -c '[ -d "$1" ]' _ "$CONFIG_FILE"; then
-            die "Safety check failed: CONFIG_FILE '$CONFIG_FILE' is a directory."
-        fi
-    elif [ -d "$CONFIG_FILE" ]; then
-        die "Safety check failed: CONFIG_FILE '$CONFIG_FILE' is a directory."
-    fi
-
-    for cmd in id uname awk grep find rm chown chmod mv mktemp mkdir tr dd sed ps head sleep cat tar gzip; do
-        command -v "$cmd" >/dev/null 2>&1 || die "Required command not found: $cmd"
-    done
-}
-
-verify_install_deps() {
-    command -v curl >/dev/null 2>&1 || command -v wget >/dev/null 2>&1 || die "Neither curl nor wget is installed."
-    command -v cp >/dev/null 2>&1 || command -v install >/dev/null 2>&1 || die "Need cp or install"
-
-    if ! command -v setcap >/dev/null 2>&1 || ! command -v conntrack >/dev/null 2>&1; then
-        if command -v apk >/dev/null 2>&1; then
-            $SUDO apk add --no-cache libcap-utils libcap conntrack-tools >/dev/null 2>&1 || true
-        elif command -v apt-get >/dev/null 2>&1; then
-            $SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y -q libcap2-bin conntrack >/dev/null 2>&1 || {
-                $SUDO env DEBIAN_FRONTEND=noninteractive apt-get update -q >/dev/null 2>&1 || true
-                $SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y -q libcap2-bin conntrack >/dev/null 2>&1 || true
-            }
-        elif command -v dnf >/dev/null 2>&1; then $SUDO dnf install -y -q libcap conntrack-tools >/dev/null 2>&1 || true
-        elif command -v yum >/dev/null 2>&1; then $SUDO yum install -y -q libcap conntrack-tools >/dev/null 2>&1 || true
-        fi
-    fi
-}
-
-check_port_availability() {
-    port_info=""
-
-    if command -v ss >/dev/null 2>&1; then
-        port_info=$($SUDO ss -tulnp 2>/dev/null | grep -E ":${SERVER_PORT}([[:space:]]|$)" || true)
-    elif command -v netstat >/dev/null 2>&1; then
-        port_info=$($SUDO netstat -tulnp 2>/dev/null | grep -E ":${SERVER_PORT}([[:space:]]|$)" || true)
-    elif command -v lsof >/dev/null 2>&1; then
-        port_info=$($SUDO lsof -i :${SERVER_PORT} 2>/dev/null | grep LISTEN || true)
-    else
-        say "[WARNING] Network diagnostic tools (ss, netstat, lsof) not found. Skipping port check."
-        return 0
-    fi
-
-    if [ -n "$port_info" ]; then
-        if printf '%s\n' "$port_info" | grep -q "${BIN_NAME}"; then
-            say "  -> Port ${SERVER_PORT} is in use by ${BIN_NAME}. Ignoring as it will be restarted."
-        else
-            say "[ERROR] Port ${SERVER_PORT} is already in use by another process:"
-            printf '  %s\n' "$port_info"
-            die "Please free the port ${SERVER_PORT} or change it and try again."
-        fi
-    fi
+need_cmd() {
+    command -v "$1" >/dev/null 2>&1 || die "required command not found: $1"
 }
 
 detect_arch() {
-    sys_arch="$(uname -m)"
-    case "$sys_arch" in
-        x86_64|amd64)
-            if [ -r /proc/cpuinfo ] && grep -q "avx2" /proc/cpuinfo 2>/dev/null && grep -q "bmi2" /proc/cpuinfo 2>/dev/null; then
-                echo "x86_64-v3"
-            else
-                echo "x86_64"
-            fi
-            ;;
-        aarch64|arm64) echo "aarch64" ;;
-        *) die "Unsupported architecture: $sys_arch" ;;
+    arch="$(uname -m)"
+    case "$arch" in
+        x86_64|amd64) printf 'x86_64\n' ;;
+        aarch64|arm64) printf 'aarch64\n' ;;
+        *) die "unsupported architecture: $arch" ;;
     esac
 }
 
 detect_libc() {
-    for f in /lib/ld-musl-*.so.* /lib64/ld-musl-*.so.*; do
-        if [ -e "$f" ]; then echo "musl"; return 0; fi
-    done
-    if grep -qE '^ID="?alpine"?' /etc/os-release 2>/dev/null; then echo "musl"; return 0; fi
-    if command -v ldd >/dev/null 2>&1 && (ldd --version 2>&1 || true) | grep -qi musl; then echo "musl"; return 0; fi
-    echo "gnu"
+    case "$(ldd --version 2>&1 || true)" in
+        *musl*) printf 'musl\n' ;;
+        *) printf 'gnu\n' ;;
+    esac
 }
 
-fetch_file() {
-    if command -v curl >/dev/null 2>&1; then curl -fsSL "$1" -o "$2"
-    else wget -q -O "$2" "$1"; fi
-}
-
-ensure_user_group() {
-    nologin_bin="$(command -v nologin 2>/dev/null || command -v false 2>/dev/null || echo /bin/false)"
-
-    if ! check_os_entity group telemt; then
-        if command -v groupadd >/dev/null 2>&1; then $SUDO groupadd -r telemt
-        elif command -v addgroup >/dev/null 2>&1; then $SUDO addgroup -S telemt
-        else die "Cannot create group"; fi
-    fi
-
-    if ! check_os_entity passwd telemt; then
-        if command -v useradd >/dev/null 2>&1; then
-            $SUDO useradd -r -g telemt -d "$WORK_DIR" -s "$nologin_bin" -c "Telemt Proxy" telemt
-        elif command -v adduser >/dev/null 2>&1; then
-            if adduser --help 2>&1 | grep -q -- '-S'; then
-                $SUDO adduser -S -D -H -h "$WORK_DIR" -s "$nologin_bin" -G telemt telemt
+fetch_to_stdout() {
+    url="$1"
+    if command -v curl >/dev/null 2>&1; then
+        curl -fsSL "$url"
+    elif command -v wget >/dev/null 2>&1; then
+        wget -qO- "$url"
     else
-                $SUDO adduser --system --home "$WORK_DIR" --shell "$nologin_bin" --no-create-home --ingroup telemt --disabled-password telemt
-            fi
-        else die "Cannot create user"; fi
-    fi
-}
-
-setup_dirs() {
-    $SUDO mkdir -p "$WORK_DIR" "$CONFIG_DIR" "$CONFIG_PARENT_DIR" || die "Failed to create directories"
-
-    $SUDO chown telemt:telemt "$WORK_DIR" && $SUDO chmod 750 "$WORK_DIR"
-    $SUDO chown root:telemt "$CONFIG_DIR" && $SUDO chmod 750 "$CONFIG_DIR"
-
-    if [ "$CONFIG_PARENT_DIR" != "$CONFIG_DIR" ] && [ "$CONFIG_PARENT_DIR" != "." ] && [ "$CONFIG_PARENT_DIR" != "/" ]; then
-        $SUDO chown root:telemt "$CONFIG_PARENT_DIR" && $SUDO chmod 750 "$CONFIG_PARENT_DIR"
-    fi
-}
-
-stop_service() {
-    svc="$(get_svc_mgr)"
-    if [ "$svc" = "systemd" ] && systemctl is-active --quiet "$SERVICE_NAME" 2>/dev/null; then
-        $SUDO systemctl stop "$SERVICE_NAME" 2>/dev/null || true
-    elif [ "$svc" = "openrc" ] && rc-service "$SERVICE_NAME" status >/dev/null 2>&1; then
-        $SUDO rc-service "$SERVICE_NAME" stop 2>/dev/null || true
+        die "neither curl nor wget is installed"
     fi
 }
 
 install_binary() {
-    bin_src="$1"; bin_dst="$2"
-    if [ -e "$INSTALL_DIR" ] && [ ! -d "$INSTALL_DIR" ]; then
-        die "'$INSTALL_DIR' is not a directory."
-    fi
+    src="$1"
+    dst="$2"
 
-    $SUDO mkdir -p "$INSTALL_DIR" || die "Failed to create install directory"
-    
-    $SUDO rm -f "$bin_dst" 2>/dev/null || true
-
-    if command -v install >/dev/null 2>&1; then
-        $SUDO install -m 0755 "$bin_src" "$bin_dst" || die "Failed to install binary"
+    if [ -w "$INSTALL_DIR" ] || { [ ! -e "$INSTALL_DIR" ] && [ -w "$(dirname "$INSTALL_DIR")" ]; }; then
+        mkdir -p "$INSTALL_DIR"
+        install -m 0755 "$src" "$dst"
+    elif command -v sudo >/dev/null 2>&1; then
+        sudo mkdir -p "$INSTALL_DIR"
+        sudo install -m 0755 "$src" "$dst"
     else
-        $SUDO cp "$bin_src" "$bin_dst" && $SUDO chmod 0755 "$bin_dst" || die "Failed to copy binary"
-    fi
-
-    $SUDO sh -c '[ -x "$1" ]' _ "$bin_dst" || die "Binary not executable: $bin_dst"
-
-    if command -v setcap >/dev/null 2>&1; then
-        $SUDO setcap cap_net_bind_service,cap_net_admin=+ep "$bin_dst" 2>/dev/null || true
+        die "cannot write to $INSTALL_DIR and sudo is not available"
     fi
 }
 
-generate_secret() {
-    secret="$(command -v openssl >/dev/null 2>&1 && openssl rand -hex 16 2>/dev/null || true)"
-    if [ -z "$secret" ] || [ "${#secret}" -ne 32 ]; then
-        if command -v od >/dev/null 2>&1; then secret="$(dd if=/dev/urandom bs=16 count=1 2>/dev/null | od -An -tx1 | tr -d ' \n')"
-        elif command -v hexdump >/dev/null 2>&1; then secret="$(dd if=/dev/urandom bs=16 count=1 2>/dev/null | hexdump -e '1/1 "%02x"')"
-        elif command -v xxd >/dev/null 2>&1; then secret="$(dd if=/dev/urandom bs=16 count=1 2>/dev/null | xxd -p | tr -d '\n')"
-        fi
-    fi
-    if [ "${#secret}" -eq 32 ]; then echo "$secret"; else return 1; fi
-}
+need_cmd uname
+need_cmd tar
+need_cmd mktemp
+need_cmd grep
+need_cmd install
 
-generate_config_content() {
-    conf_secret="$1"
-    conf_tag="$2"
-    escaped_tls_domain="$(printf '%s\n' "$TLS_DOMAIN" | tr -d '[:cntrl:]' | sed 's/\\/\\\\/g; s/"/\\"/g')"
+ARCH="$(detect_arch)"
+LIBC="$(detect_libc)"
 
-    cat <<EOF
-[general]
-use_middle_proxy = true
-EOF
-
-    if [ -n "$conf_tag" ]; then
-        echo "ad_tag = \"${conf_tag}\""
-    fi
-
-    cat <<EOF
-
-[general.modes]
-classic = false
-secure = false
-tls = true
-
-[server]
-port = ${SERVER_PORT}
-
-[server.api]
-enabled = true
-listen = "127.0.0.1:9091"
-whitelist = ["127.0.0.1/32"]
-
-[censorship]
-tls_domain = "${escaped_tls_domain}"
-
-[access.users]
-hello = "${conf_secret}"
-EOF
-}
-
-install_config() {
-    if is_config_exists; then
-        say "  -> Config already exists at $CONFIG_FILE. Updating parameters..."
-
-        tmp_conf="${TEMP_DIR}/config.tmp"
-        $SUDO cat "$CONFIG_FILE" > "$tmp_conf"
-        
-        escaped_domain="$(printf '%s\n' "$TLS_DOMAIN" | tr -d '[:cntrl:]' | sed 's/\\/\\\\/g; s/"/\\"/g')"
-
-        export AWK_PORT="$SERVER_PORT"
-        export AWK_SECRET="$USER_SECRET"
-        export AWK_DOMAIN="$escaped_domain"
-        export AWK_AD_TAG="$AD_TAG"
-        export AWK_FLAG_P="$PORT_PROVIDED"
-        export AWK_FLAG_S="$SECRET_PROVIDED"
-        export AWK_FLAG_D="$DOMAIN_PROVIDED"
-        export AWK_FLAG_A="$AD_TAG_PROVIDED"
-
-        awk '
-        BEGIN { ad_tag_handled = 0 }
-        
-        ENVIRON["AWK_FLAG_P"] == "1" && /^[ \t]*port[ \t]*=/ { print "port = " ENVIRON["AWK_PORT"]; next }
-        ENVIRON["AWK_FLAG_S"] == "1" && /^[ \t]*hello[ \t]*=/ { print "hello = \"" ENVIRON["AWK_SECRET"] "\""; next }
-        ENVIRON["AWK_FLAG_D"] == "1" && /^[ \t]*tls_domain[ \t]*=/ { print "tls_domain = \"" ENVIRON["AWK_DOMAIN"] "\""; next }
-        
-        ENVIRON["AWK_FLAG_A"] == "1" && /^[ \t]*ad_tag[ \t]*=/ { 
-            if (!ad_tag_handled) { 
-                print "ad_tag = \"" ENVIRON["AWK_AD_TAG"] "\""; 
-                ad_tag_handled = 1; 
-            } 
-            next 
-        }
-        ENVIRON["AWK_FLAG_A"] == "1" && /^\[general\]/ { 
-            print; 
-            if (!ad_tag_handled) { 
-                print "ad_tag = \"" ENVIRON["AWK_AD_TAG"] "\""; 
-                ad_tag_handled = 1; 
-            } 
-            next 
-        }
-        
-        { print }
-        ' "$tmp_conf" > "${tmp_conf}.new" && mv "${tmp_conf}.new" "$tmp_conf"
-
-        [ "$PORT_PROVIDED" -eq 1 ] && say "  -> Updated port: $SERVER_PORT"
-        [ "$SECRET_PROVIDED" -eq 1 ] && say "  -> Updated secret for user 'hello'"
-        [ "$DOMAIN_PROVIDED" -eq 1 ] && say "  -> Updated tls_domain: $TLS_DOMAIN"
-        [ "$AD_TAG_PROVIDED" -eq 1 ] && say "  -> Updated ad_tag"
-
-        write_root "$CONFIG_FILE" < "$tmp_conf"
-        rm -f "$tmp_conf"
-        return 0
-    fi
-
-    if [ -z "$USER_SECRET" ]; then
-        USER_SECRET="$(generate_secret)" || die "Failed to generate secret."
-    fi
-
-    generate_config_content "$USER_SECRET" "$AD_TAG" | write_root "$CONFIG_FILE" || die "Failed to install config"
-    $SUDO chown root:telemt "$CONFIG_FILE" && $SUDO chmod 640 "$CONFIG_FILE"
-
-    say "  -> Config created successfully."
-    say "  -> Configured secret for user 'hello': $USER_SECRET"
-}
-
-generate_systemd_content() {
-    cat <<EOF
-[Unit]
-Description=Telemt
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=telemt
-Group=telemt
-WorkingDirectory=$WORK_DIR
-ExecStart="${INSTALL_DIR}/${BIN_NAME}" "${CONFIG_FILE}"
-Restart=on-failure
-RestartSec=5
-LimitNOFILE=65536
-AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_NET_ADMIN
-CapabilityBoundingSet=CAP_NET_BIND_SERVICE CAP_NET_ADMIN
-
-[Install]
-WantedBy=multi-user.target
-EOF
-}
-
-generate_openrc_content() {
-    cat <<EOF
-#!/sbin/openrc-run
-name="$SERVICE_NAME"
-description="Telemt Proxy Service"
-command="${INSTALL_DIR}/${BIN_NAME}"
-command_args="${CONFIG_FILE}"
-command_background=true
-command_user="telemt:telemt"
-pidfile="/run/\${RC_SVCNAME}.pid"
-directory="${WORK_DIR}"
-rc_ulimit="-n 65536"
-depend() { need net; use logger; }
-EOF
-}
-
-install_service() {
-    svc="$(get_svc_mgr)"
-    if [ "$svc" = "systemd" ]; then
-        generate_systemd_content | write_root "/etc/systemd/system/${SERVICE_NAME}.service"
-        $SUDO chown root:root "/etc/systemd/system/${SERVICE_NAME}.service" && $SUDO chmod 644 "/etc/systemd/system/${SERVICE_NAME}.service"
-
-        $SUDO systemctl daemon-reload || true
-        $SUDO systemctl enable "$SERVICE_NAME" || true
-
-        if ! $SUDO systemctl start "$SERVICE_NAME"; then
-            say "[WARNING] Failed to start service"
-            SERVICE_START_FAILED=1
-        fi
-    elif [ "$svc" = "openrc" ]; then
-        generate_openrc_content | write_root "/etc/init.d/${SERVICE_NAME}"
-        $SUDO chown root:root "/etc/init.d/${SERVICE_NAME}" && $SUDO chmod 0755 "/etc/init.d/${SERVICE_NAME}"
-
-        $SUDO rc-update add "$SERVICE_NAME" default 2>/dev/null || true
-
-        if ! $SUDO rc-service "$SERVICE_NAME" start 2>/dev/null; then
-            say "[WARNING] Failed to start service"
-            SERVICE_START_FAILED=1
-        fi
-    else
-        cmd="\"${INSTALL_DIR}/${BIN_NAME}\" \"${CONFIG_FILE}\""
-        if [ -n "$SUDO" ]; then
-            say "  -> Service manager not found. Start manually: sudo -u telemt $cmd"
-        else
-            say "  -> Service manager not found. Start manually: su -s /bin/sh telemt -c '$cmd'"
-        fi
-    fi
-}
-
-kill_user_procs() {
-    if command -v pkill >/dev/null 2>&1; then
-        $SUDO pkill -u telemt "$BIN_NAME" 2>/dev/null || true
-        sleep 1
-        $SUDO pkill -9 -u telemt "$BIN_NAME" 2>/dev/null || true
-    else
-        if command -v pgrep >/dev/null 2>&1; then
-            pids="$(pgrep -u telemt 2>/dev/null || true)"
-        else
-            pids="$(ps -ef 2>/dev/null | awk '$1=="telemt"{print $2}' || true)"
-            [ -z "$pids" ] && pids="$(ps 2>/dev/null | awk '$2=="telemt"{print $1}' || true)"
-        fi
-
-        if [ -n "$pids" ]; then
-            for pid in $pids; do
-                case "$pid" in ''|*[!0-9]*) continue ;; *) $SUDO kill "$pid" 2>/dev/null || true ;; esac
-            done
-            sleep 1
-            for pid in $pids; do
-                case "$pid" in ''|*[!0-9]*) continue ;; *) $SUDO kill -9 "$pid" 2>/dev/null || true ;; esac
-            done
-        fi
-    fi
-}
-
-uninstall() {
-    say "Starting uninstallation of $BIN_NAME..."
-
-    say ">>> Stage 1: Stopping services"
-    stop_service
-
-    say ">>> Stage 2: Removing service configuration"
-    svc="$(get_svc_mgr)"
-    if [ "$svc" = "systemd" ]; then
-        $SUDO systemctl disable "$SERVICE_NAME" 2>/dev/null || true
-        $SUDO rm -f "/etc/systemd/system/${SERVICE_NAME}.service"
-        $SUDO systemctl daemon-reload 2>/dev/null || true
-    elif [ "$svc" = "openrc" ]; then
-        $SUDO rc-update del "$SERVICE_NAME" 2>/dev/null || true
-        $SUDO rm -f "/etc/init.d/${SERVICE_NAME}"
-    fi
-
-    say ">>> Stage 3: Terminating user processes"
-    kill_user_procs
-
-    say ">>> Stage 4: Removing binary"
-    $SUDO rm -f "${INSTALL_DIR}/${BIN_NAME}"
-
-    if [ "$ACTION" = "purge" ]; then
-        say ">>> Stage 5: Purging configuration, data, and user"
-        $SUDO rm -rf "$CONFIG_DIR" "$WORK_DIR"
-        $SUDO rm -f "$CONFIG_FILE"
-        sleep 1 
-        $SUDO userdel telemt 2>/dev/null || $SUDO deluser telemt 2>/dev/null || true
-        
-        if check_os_entity group telemt; then
-            $SUDO groupdel telemt 2>/dev/null || $SUDO delgroup telemt 2>/dev/null || true
-        fi
-    else
-        say "Note: Configuration and user kept. Run with 'purge' to remove completely."
-    fi
-
-    printf '\n====================================================================\n'
-    printf '                    UNINSTALLATION COMPLETE\n'
-    printf '====================================================================\n\n'
-    exit 0
-}
-
-case "$ACTION" in
-    help) show_help ;;
-    uninstall|purge) verify_common; uninstall ;;
-    install)
-        say "Starting installation of $BIN_NAME (Version: $TARGET_VERSION)"
-
-        say ">>> Stage 1: Verifying environment and dependencies"
-        verify_common
-        verify_install_deps
-
-        if is_config_exists && [ "$PORT_PROVIDED" -eq 0 ]; then
-            ext_port="$($SUDO awk -F'=' '/^[ \t]*port[ \t]*=/ {gsub(/[^0-9]/, "", $2); print $2; exit}' "$CONFIG_FILE" 2>/dev/null || true)"
-            if [ -n "$ext_port" ]; then
-                SERVER_PORT="$ext_port"
-            fi
-        fi
-
-        check_port_availability
-
-        if [ "$TARGET_VERSION" != "latest" ]; then
-            TARGET_VERSION="${TARGET_VERSION#v}"
-        fi
-
-        ARCH="$(detect_arch)"; LIBC="$(detect_libc)"
-        FILE_NAME="${BIN_NAME}-${ARCH}-linux-${LIBC}.tar.gz"
-
-        if [ "$TARGET_VERSION" = "latest" ]; then
-            DL_URL="https://github.com/${REPO}/releases/latest/download/${FILE_NAME}"
-        else
-            DL_URL="https://github.com/${REPO}/releases/download/${TARGET_VERSION}/${FILE_NAME}"
-        fi
-
-        say ">>> Stage 2: Downloading archive"
-        TEMP_DIR="$(mktemp -d)" || die "Temp directory creation failed"
-        if [ -z "$TEMP_DIR" ] || [ ! -d "$TEMP_DIR" ]; then
-            die "Temp directory is invalid or was not created"
-        fi
-
-        if ! fetch_file "$DL_URL" "${TEMP_DIR}/${FILE_NAME}"; then
-            if [ "$ARCH" = "x86_64-v3" ]; then
-                say "  -> x86_64-v3 build not found, falling back to standard x86_64..."
-                ARCH="x86_64"
-                FILE_NAME="${BIN_NAME}-${ARCH}-linux-${LIBC}.tar.gz"
-                if [ "$TARGET_VERSION" = "latest" ]; then
-                    DL_URL="https://github.com/${REPO}/releases/latest/download/${FILE_NAME}"
-                else
-                    DL_URL="https://github.com/${REPO}/releases/download/${TARGET_VERSION}/${FILE_NAME}"
-                fi
-                fetch_file "$DL_URL" "${TEMP_DIR}/${FILE_NAME}" || die "Download failed"
-            else
-                die "Download failed"
-            fi
-        fi
-
-        say ">>> Stage 3: Extracting archive"
-        if ! gzip -dc "${TEMP_DIR}/${FILE_NAME}" | tar -xf - -C "$TEMP_DIR" 2>/dev/null; then
-            die "Extraction failed (downloaded archive might be invalid or 404)."
-        fi
-
-        EXTRACTED_BIN="$(find "$TEMP_DIR" -type f -name "$BIN_NAME" -print 2>/dev/null | head -n 1 || true)"
-        [ -n "$EXTRACTED_BIN" ] || die "Binary '$BIN_NAME' not found in archive"
-
-        say ">>> Stage 4: Setting up environment (User, Group, Directories)"
-        ensure_user_group; setup_dirs; stop_service
-
-        say ">>> Stage 5: Installing binary"
-        install_binary "$EXTRACTED_BIN" "${INSTALL_DIR}/${BIN_NAME}"
-
-        say ">>> Stage 6: Generating/Updating configuration"
-        install_config
-
-        say ">>> Stage 7: Installing and starting service"
-        install_service
-
-        if [ "${SERVICE_START_FAILED:-0}" -eq 1 ]; then
-            printf '\n====================================================================\n'
-            printf '               INSTALLATION COMPLETED WITH WARNINGS\n'
-            printf '====================================================================\n\n'
-            printf 'The service was installed but failed to start automatically.\n'
-            printf 'Please check the logs to determine the issue.\n\n'
-        else
-            printf '\n====================================================================\n'
-            printf '                      INSTALLATION SUCCESS\n'
-            printf '====================================================================\n\n'
-        fi
-
-        svc="$(get_svc_mgr)"
-        if [ "$svc" = "systemd" ]; then
-            printf 'To check the status of your proxy service, run:\n'
-            printf '  systemctl status %s\n\n' "$SERVICE_NAME"
-        elif [ "$svc" = "openrc" ]; then
-            printf 'To check the status of your proxy service, run:\n'
-            printf '  rc-service %s status\n\n' "$SERVICE_NAME"
-        fi
-
-        API_LISTEN="$($SUDO awk -F'"' '/^[ \t]*listen[ \t]*=/ {print $2; exit}' "$CONFIG_FILE" 2>/dev/null || true)"
-        API_LISTEN="${API_LISTEN:-127.0.0.1:9091}"
-
-        printf 'To get your user connection links (for Telegram), run:\n'
-        if command -v jq >/dev/null 2>&1; then
-            printf '  curl -s http://%s/v1/users | jq -r '\''.data[]? | "User: \\(.username)\\n\\(.links.tls[0] // empty)\\n"'\''\n' "$API_LISTEN"
-        else
-            printf '  curl -s http://%s/v1/users\n' "$API_LISTEN"
-            printf '  (Tip: Install '\''jq'\'' for a much cleaner output)\n'
-        fi
-
-        printf '\n====================================================================\n'
+case "$VERSION" in
+    latest)
+        URL="https://github.com/$REPO/releases/latest/download/${BIN_NAME}-${ARCH}-linux-${LIBC}.tar.gz"
+        ;;
+    *)
+        URL="https://github.com/$REPO/releases/download/${VERSION}/${BIN_NAME}-${ARCH}-linux-${LIBC}.tar.gz"
         ;;
 esac
+
+TMPDIR="$(mktemp -d)"
+trap 'rm -rf "$TMPDIR"' EXIT INT TERM
+
+say "Installing $BIN_NAME ($VERSION) for $ARCH-linux-$LIBC..."
+fetch_to_stdout "$URL" | tar -xzf - -C "$TMPDIR"
+
+[ -f "$TMPDIR/$BIN_NAME" ] || die "archive did not contain $BIN_NAME"
+
+install_binary "$TMPDIR/$BIN_NAME" "$INSTALL_DIR/$BIN_NAME"
+
+say "Installed: $INSTALL_DIR/$BIN_NAME"
+"$INSTALL_DIR/$BIN_NAME" --version 2>/dev/null || true

src/api/config_store.rs

@@ -1,39 +1,13 @@
-use std::collections::BTreeMap;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
-use chrono::{DateTime, Utc};
 use hyper::header::IF_MATCH;
-use serde::Serialize;
 use sha2::{Digest, Sha256};
 
 use crate::config::ProxyConfig;
 
 use super::model::ApiFailure;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(super) enum AccessSection {
-    Users,
-    UserAdTags,
-    UserMaxTcpConns,
-    UserExpirations,
-    UserDataQuota,
-    UserMaxUniqueIps,
-}
-
-impl AccessSection {
-    fn table_name(self) -> &'static str {
-        match self {
-            Self::Users => "access.users",
-            Self::UserAdTags => "access.user_ad_tags",
-            Self::UserMaxTcpConns => "access.user_max_tcp_conns",
-            Self::UserExpirations => "access.user_expirations",
-            Self::UserDataQuota => "access.user_data_quota",
-            Self::UserMaxUniqueIps => "access.user_max_unique_ips",
-        }
-    }
-}
-
 pub(super) fn parse_if_match(headers: &hyper::HeaderMap) -> Option<String> {
     headers
         .get(IF_MATCH)
@@ -92,142 +66,6 @@ pub(super) async fn save_config_to_disk(
     Ok(compute_revision(&serialized))
 }
 
-pub(super) async fn save_access_sections_to_disk(
-    config_path: &Path,
-    cfg: &ProxyConfig,
-    sections: &[AccessSection],
-) -> Result<String, ApiFailure> {
-    let mut content = tokio::fs::read_to_string(config_path)
-        .await
-        .map_err(|e| ApiFailure::internal(format!("failed to read config: {}", e)))?;
-
-    let mut applied = Vec::new();
-    for section in sections {
-        if applied.contains(section) {
-            continue;
-        }
-        let rendered = render_access_section(cfg, *section)?;
-        content = upsert_toml_table(&content, section.table_name(), &rendered);
-        applied.push(*section);
-    }
-
-    write_atomic(config_path.to_path_buf(), content.clone()).await?;
-    Ok(compute_revision(&content))
-}
-
-fn render_access_section(cfg: &ProxyConfig, section: AccessSection) -> Result<String, ApiFailure> {
-    let body = match section {
-        AccessSection::Users => {
-            let rows: BTreeMap<String, String> = cfg
-                .access
-                .users
-                .iter()
-                .map(|(key, value)| (key.clone(), value.clone()))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-        AccessSection::UserAdTags => {
-            let rows: BTreeMap<String, String> = cfg
-                .access
-                .user_ad_tags
-                .iter()
-                .map(|(key, value)| (key.clone(), value.clone()))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-        AccessSection::UserMaxTcpConns => {
-            let rows: BTreeMap<String, usize> = cfg
-                .access
-                .user_max_tcp_conns
-                .iter()
-                .map(|(key, value)| (key.clone(), *value))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-        AccessSection::UserExpirations => {
-            let rows: BTreeMap<String, DateTime<Utc>> = cfg
-                .access
-                .user_expirations
-                .iter()
-                .map(|(key, value)| (key.clone(), *value))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-        AccessSection::UserDataQuota => {
-            let rows: BTreeMap<String, u64> = cfg
-                .access
-                .user_data_quota
-                .iter()
-                .map(|(key, value)| (key.clone(), *value))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-        AccessSection::UserMaxUniqueIps => {
-            let rows: BTreeMap<String, usize> = cfg
-                .access
-                .user_max_unique_ips
-                .iter()
-                .map(|(key, value)| (key.clone(), *value))
-                .collect();
-            serialize_table_body(&rows)?
-        }
-    };
-
-    let mut out = format!("[{}]\n", section.table_name());
-    if !body.is_empty() {
-        out.push_str(&body);
-    }
-    if !out.ends_with('\n') {
-        out.push('\n');
-    }
-    Ok(out)
-}
-
-fn serialize_table_body<T: Serialize>(value: &T) -> Result<String, ApiFailure> {
-    toml::to_string(value)
-        .map_err(|e| ApiFailure::internal(format!("failed to serialize access section: {}", e)))
-}
-
-fn upsert_toml_table(source: &str, table_name: &str, replacement: &str) -> String {
-    if let Some((start, end)) = find_toml_table_bounds(source, table_name) {
-        let mut out = String::with_capacity(source.len() + replacement.len());
-        out.push_str(&source[..start]);
-        out.push_str(replacement);
-        out.push_str(&source[end..]);
-        return out;
-    }
-
-    let mut out = source.to_string();
-    if !out.is_empty() && !out.ends_with('\n') {
-        out.push('\n');
-    }
-    if !out.is_empty() {
-        out.push('\n');
-    }
-    out.push_str(replacement);
-    out
-}
-
-fn find_toml_table_bounds(source: &str, table_name: &str) -> Option<(usize, usize)> {
-    let target = format!("[{}]", table_name);
-    let mut offset = 0usize;
-    let mut start = None;
-
-    for line in source.split_inclusive('\n') {
-        let trimmed = line.trim();
-        if let Some(start_offset) = start {
-            if trimmed.starts_with('[') {
-                return Some((start_offset, offset));
-            }
-        } else if trimmed == target {
-            start = Some(offset);
-        }
-        offset = offset.saturating_add(line.len());
-    }
-
-    start.map(|start_offset| (start_offset, source.len()))
-}
-
 async fn write_atomic(path: PathBuf, contents: String) -> Result<(), ApiFailure> {
     tokio::task::spawn_blocking(move || write_atomic_sync(&path, &contents))
         .await

src/api/http_utils.rs

@@ -24,7 +24,10 @@ pub(super) fn success_response<T: Serialize>(
         .unwrap()
 }
 
-pub(super) fn error_response(request_id: u64, failure: ApiFailure) -> hyper::Response<Full<Bytes>> {
+pub(super) fn error_response(
+    request_id: u64,
+    failure: ApiFailure,
+) -> hyper::Response<Full<Bytes>> {
     let payload = ErrorResponse {
         ok: false,
         error: ErrorBody {

src/api/mod.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::too_many_arguments)]
-
 use std::convert::Infallible;
 use std::net::{IpAddr, SocketAddr};
 use std::path::PathBuf;
@@ -18,11 +16,10 @@ use tracing::{debug, info, warn};
 
 use crate::config::ProxyConfig;
 use crate::ip_tracker::UserIpTracker;
-use crate::proxy::route_mode::RouteRuntimeController;
 use crate::startup::StartupTracker;
 use crate::stats::Stats;
-use crate::transport::UpstreamManager;
 use crate::transport::middle_proxy::MePool;
+use crate::transport::UpstreamManager;
 
 mod config_store;
 mod events;
@@ -31,18 +28,16 @@ mod model;
 mod runtime_edge;
 mod runtime_init;
 mod runtime_min;
-mod runtime_selftest;
 mod runtime_stats;
 mod runtime_watch;
 mod runtime_zero;
 mod users;
 
-use config_store::{current_revision, load_config_from_disk, parse_if_match};
-use events::ApiEventStore;
+use config_store::{current_revision, parse_if_match};
 use http_utils::{error_response, read_json, read_optional_json, success_response};
+use events::ApiEventStore;
 use model::{
-    ApiFailure, CreateUserRequest, DeleteUserResponse, HealthData, PatchUserRequest,
-    RotateSecretRequest, SummaryData, UserActiveIps,
+    ApiFailure, CreateUserRequest, HealthData, PatchUserRequest, RotateSecretRequest, SummaryData,
 };
 use runtime_edge::{
     EdgeConnectionsCacheEntry, build_runtime_connections_summary_data,
@@ -53,16 +48,15 @@ use runtime_min::{
     build_runtime_me_pool_state_data, build_runtime_me_quality_data, build_runtime_nat_stun_data,
     build_runtime_upstream_quality_data, build_security_whitelist_data,
 };
-use runtime_selftest::build_runtime_me_selftest_data;
 use runtime_stats::{
     MinimalCacheEntry, build_dcs_data, build_me_writers_data, build_minimal_all_data,
     build_upstreams_data, build_zero_all_data,
 };
-use runtime_watch::spawn_runtime_watchers;
 use runtime_zero::{
     build_limits_effective_data, build_runtime_gates_data, build_security_posture_data,
     build_system_info_data,
 };
+use runtime_watch::spawn_runtime_watchers;
 use users::{create_user, delete_user, patch_user, rotate_secret, users_from_config};
 
 pub(super) struct ApiRuntimeState {
@@ -79,7 +73,8 @@ pub(super) struct ApiShared {
     pub(super) me_pool: Arc<RwLock<Option<Arc<MePool>>>>,
     pub(super) upstream_manager: Arc<UpstreamManager>,
     pub(super) config_path: PathBuf,
-    pub(super) detected_ips_rx: watch::Receiver<(Option<IpAddr>, Option<IpAddr>)>,
+    pub(super) startup_detected_ip_v4: Option<IpAddr>,
+    pub(super) startup_detected_ip_v6: Option<IpAddr>,
     pub(super) mutation_lock: Arc<Mutex<()>>,
     pub(super) minimal_cache: Arc<Mutex<Option<MinimalCacheEntry>>>,
     pub(super) runtime_edge_connections_cache: Arc<Mutex<Option<EdgeConnectionsCacheEntry>>>,
@@ -88,17 +83,12 @@ pub(super) struct ApiShared {
     pub(super) request_id: Arc<AtomicU64>,
     pub(super) runtime_state: Arc<ApiRuntimeState>,
     pub(super) startup_tracker: Arc<StartupTracker>,
-    pub(super) route_runtime: Arc<RouteRuntimeController>,
 }
 
 impl ApiShared {
     fn next_request_id(&self) -> u64 {
         self.request_id.fetch_add(1, Ordering::Relaxed)
     }
-
-    fn detected_link_ips(&self) -> (Option<IpAddr>, Option<IpAddr>) {
-        *self.detected_ips_rx.borrow()
-    }
 }
 
 pub async fn serve(
@@ -106,12 +96,12 @@ pub async fn serve(
     stats: Arc<Stats>,
     ip_tracker: Arc<UserIpTracker>,
     me_pool: Arc<RwLock<Option<Arc<MePool>>>>,
-    route_runtime: Arc<RouteRuntimeController>,
     upstream_manager: Arc<UpstreamManager>,
     config_rx: watch::Receiver<Arc<ProxyConfig>>,
     admission_rx: watch::Receiver<bool>,
     config_path: PathBuf,
-    detected_ips_rx: watch::Receiver<(Option<IpAddr>, Option<IpAddr>)>,
+    startup_detected_ip_v4: Option<IpAddr>,
+    startup_detected_ip_v6: Option<IpAddr>,
     process_started_at_epoch_secs: u64,
     startup_tracker: Arc<StartupTracker>,
 ) {
@@ -142,7 +132,8 @@ pub async fn serve(
         me_pool,
         upstream_manager,
         config_path,
-        detected_ips_rx,
+        startup_detected_ip_v4,
+        startup_detected_ip_v6,
         mutation_lock: Arc::new(Mutex::new(())),
         minimal_cache: Arc::new(Mutex::new(None)),
         runtime_edge_connections_cache: Arc::new(Mutex::new(None)),
@@ -153,7 +144,6 @@ pub async fn serve(
         request_id: Arc::new(AtomicU64::new(1)),
         runtime_state: runtime_state.clone(),
         startup_tracker,
-        route_runtime,
     });
 
     spawn_runtime_watchers(
@@ -211,15 +201,15 @@ async fn handle(
         ));
     }
 
-    if !api_cfg.whitelist.is_empty() && !api_cfg.whitelist.iter().any(|net| net.contains(peer.ip()))
+    if !api_cfg.whitelist.is_empty()
+        && !api_cfg
+            .whitelist
+            .iter()
+            .any(|net| net.contains(peer.ip()))
     {
         return Ok(error_response(
             request_id,
-            ApiFailure::new(
-                StatusCode::FORBIDDEN,
-                "forbidden",
-                "Source IP is not allowed",
-            ),
+            ApiFailure::new(StatusCode::FORBIDDEN, "forbidden", "Source IP is not allowed"),
         ));
     }
 
@@ -343,15 +333,9 @@ async fn handle(
                 let data = build_runtime_nat_stun_data(shared.as_ref()).await;
                 Ok(success_response(StatusCode::OK, data, revision))
             }
-            ("GET", "/v1/runtime/me-selftest") => {
-                let revision = current_revision(&shared.config_path).await?;
-                let data = build_runtime_me_selftest_data(shared.as_ref(), cfg.as_ref()).await;
-                Ok(success_response(StatusCode::OK, data, revision))
-            }
             ("GET", "/v1/runtime/connections/summary") => {
                 let revision = current_revision(&shared.config_path).await?;
-                let data =
-                    build_runtime_connections_summary_data(shared.as_ref(), cfg.as_ref()).await;
+                let data = build_runtime_connections_summary_data(shared.as_ref(), cfg.as_ref()).await;
                 Ok(success_response(StatusCode::OK, data, revision))
             }
             ("GET", "/v1/runtime/events/recent") => {
@@ -363,33 +347,14 @@ async fn handle(
                 );
                 Ok(success_response(StatusCode::OK, data, revision))
             }
-            ("GET", "/v1/stats/users/active-ips") => {
-                let revision = current_revision(&shared.config_path).await?;
-                let usernames: Vec<_> = cfg.access.users.keys().cloned().collect();
-                let active_ips_map = shared.ip_tracker.get_active_ips_for_users(&usernames).await;
-                let mut data: Vec<UserActiveIps> = active_ips_map
-                    .into_iter()
-                    .filter(|(_, ips)| !ips.is_empty())
-                    .map(|(username, active_ips)| UserActiveIps {
-                        username,
-                        active_ips,
-                    })
-                    .collect();
-                data.sort_by(|a, b| a.username.cmp(&b.username));
-                Ok(success_response(StatusCode::OK, data, revision))
-            }
             ("GET", "/v1/stats/users") | ("GET", "/v1/users") => {
                 let revision = current_revision(&shared.config_path).await?;
-                let disk_cfg = load_config_from_disk(&shared.config_path).await?;
-                let runtime_cfg = config_rx.borrow().clone();
-                let (detected_ip_v4, detected_ip_v6) = shared.detected_link_ips();
                 let users = users_from_config(
-                    &disk_cfg,
+                    &cfg,
                     &shared.stats,
                     &shared.ip_tracker,
-                    detected_ip_v4,
-                    detected_ip_v6,
-                    Some(runtime_cfg.as_ref()),
+                    shared.startup_detected_ip_v4,
+                    shared.startup_detected_ip_v6,
                 )
                 .await;
                 Ok(success_response(StatusCode::OK, users, revision))
@@ -408,27 +373,17 @@ async fn handle(
                 let expected_revision = parse_if_match(req.headers());
                 let body = read_json::<CreateUserRequest>(req.into_body(), body_limit).await?;
                 let result = create_user(body, expected_revision, &shared).await;
-                let (mut data, revision) = match result {
+                let (data, revision) = match result {
                     Ok(ok) => ok,
                     Err(error) => {
-                        shared
-                            .runtime_events
-                            .record("api.user.create.failed", error.code);
+                        shared.runtime_events.record("api.user.create.failed", error.code);
                         return Err(error);
                     }
                 };
-                let runtime_cfg = config_rx.borrow().clone();
-                data.user.in_runtime = runtime_cfg.access.users.contains_key(&data.user.username);
-                shared.runtime_events.record(
-                    "api.user.create.ok",
-                    format!("username={}", data.user.username),
-                );
-                let status = if data.user.in_runtime {
-                    StatusCode::CREATED
-                } else {
-                    StatusCode::ACCEPTED
-                };
-                Ok(success_response(status, data, revision))
+                shared
+                    .runtime_events
+                    .record("api.user.create.ok", format!("username={}", data.user.username));
+                Ok(success_response(StatusCode::CREATED, data, revision))
             }
             _ => {
                 if let Some(user) = path.strip_prefix("/v1/users/")
@@ -437,20 +392,15 @@ async fn handle(
                 {
                     if method == Method::GET {
                         let revision = current_revision(&shared.config_path).await?;
-                        let disk_cfg = load_config_from_disk(&shared.config_path).await?;
-                        let runtime_cfg = config_rx.borrow().clone();
-                        let (detected_ip_v4, detected_ip_v6) = shared.detected_link_ips();
                         let users = users_from_config(
-                            &disk_cfg,
+                            &cfg,
                             &shared.stats,
                             &shared.ip_tracker,
-                            detected_ip_v4,
-                            detected_ip_v6,
-                            Some(runtime_cfg.as_ref()),
+                            shared.startup_detected_ip_v4,
+                            shared.startup_detected_ip_v6,
                         )
                         .await;
-                        if let Some(user_info) =
-                            users.into_iter().find(|entry| entry.username == user)
+                        if let Some(user_info) = users.into_iter().find(|entry| entry.username == user)
                         {
                             return Ok(success_response(StatusCode::OK, user_info, revision));
                         }
@@ -471,10 +421,9 @@ async fn handle(
                             ));
                         }
                         let expected_revision = parse_if_match(req.headers());
-                        let body =
-                            read_json::<PatchUserRequest>(req.into_body(), body_limit).await?;
+                        let body = read_json::<PatchUserRequest>(req.into_body(), body_limit).await?;
                         let result = patch_user(user, body, expected_revision, &shared).await;
-                        let (mut data, revision) = match result {
+                        let (data, revision) = match result {
                             Ok(ok) => ok,
                             Err(error) => {
                                 shared.runtime_events.record(
@@ -484,17 +433,10 @@ async fn handle(
                                 return Err(error);
                             }
                         };
-                        let runtime_cfg = config_rx.borrow().clone();
-                        data.in_runtime = runtime_cfg.access.users.contains_key(&data.username);
                         shared
                             .runtime_events
                             .record("api.user.patch.ok", format!("username={}", data.username));
-                        let status = if data.in_runtime {
-                            StatusCode::OK
-                        } else {
-                            StatusCode::ACCEPTED
-                        };
-                        return Ok(success_response(status, data, revision));
+                        return Ok(success_response(StatusCode::OK, data, revision));
                     }
                     if method == Method::DELETE {
                         if api_cfg.read_only {
@@ -519,21 +461,11 @@ async fn handle(
                                 return Err(error);
                             }
                         };
-                        shared
-                            .runtime_events
-                            .record("api.user.delete.ok", format!("username={}", deleted_user));
-                        let runtime_cfg = config_rx.borrow().clone();
-                        let in_runtime = runtime_cfg.access.users.contains_key(&deleted_user);
-                        let response = DeleteUserResponse {
-                            username: deleted_user,
-                            in_runtime,
-                        };
-                        let status = if response.in_runtime {
-                            StatusCode::ACCEPTED
-                        } else {
-                            StatusCode::OK
-                        };
-                        return Ok(success_response(status, response, revision));
+                        shared.runtime_events.record(
+                            "api.user.delete.ok",
+                            format!("username={}", deleted_user),
+                        );
+                        return Ok(success_response(StatusCode::OK, deleted_user, revision));
                     }
                     if method == Method::POST
                         && let Some(base_user) = user.strip_suffix("/rotate-secret")
@@ -561,7 +493,7 @@ async fn handle(
                             &shared,
                         )
                         .await;
-                        let (mut data, revision) = match result {
+                        let (data, revision) = match result {
                             Ok(ok) => ok,
                             Err(error) => {
                                 shared.runtime_events.record(
@@ -571,19 +503,11 @@ async fn handle(
                                 return Err(error);
                             }
                         };
-                        let runtime_cfg = config_rx.borrow().clone();
-                        data.user.in_runtime =
-                            runtime_cfg.access.users.contains_key(&data.user.username);
                         shared.runtime_events.record(
                             "api.user.rotate_secret.ok",
                             format!("username={}", base_user),
                         );
-                        let status = if data.user.in_runtime {
-                            StatusCode::OK
-                        } else {
-                            StatusCode::ACCEPTED
-                        };
-                        return Ok(success_response(status, data, revision));
+                        return Ok(success_response(StatusCode::OK, data, revision));
                     }
                     if method == Method::POST {
                         return Ok(error_response(

src/api/model.rs

@@ -1,12 +1,10 @@
 use std::net::IpAddr;
-use std::sync::OnceLock;
 
 use chrono::{DateTime, Utc};
 use hyper::StatusCode;
+use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use crate::crypto::SecureRandom;
-
 const MAX_USERNAME_LEN: usize = 64;
 
 #[derive(Debug)]
@@ -81,21 +79,10 @@ pub(super) struct ZeroCoreData {
     pub(super) connections_total: u64,
     pub(super) connections_bad_total: u64,
     pub(super) handshake_timeouts_total: u64,
-    pub(super) accept_permit_timeout_total: u64,
     pub(super) configured_users: usize,
     pub(super) telemetry_core_enabled: bool,
     pub(super) telemetry_user_enabled: bool,
     pub(super) telemetry_me_level: String,
-    pub(super) conntrack_control_enabled: bool,
-    pub(super) conntrack_control_available: bool,
-    pub(super) conntrack_pressure_active: bool,
-    pub(super) conntrack_event_queue_depth: u64,
-    pub(super) conntrack_rule_apply_ok: bool,
-    pub(super) conntrack_delete_attempt_total: u64,
-    pub(super) conntrack_delete_success_total: u64,
-    pub(super) conntrack_delete_not_found_total: u64,
-    pub(super) conntrack_delete_error_total: u64,
-    pub(super) conntrack_close_event_drop_total: u64,
 }
 
 #[derive(Serialize, Clone)]
@@ -147,7 +134,6 @@ pub(super) struct UpstreamSummaryData {
     pub(super) direct_total: usize,
     pub(super) socks4_total: usize,
     pub(super) socks5_total: usize,
-    pub(super) shadowsocks_total: usize,
 }
 
 #[derive(Serialize, Clone)]
@@ -185,24 +171,6 @@ pub(super) struct ZeroMiddleProxyData {
     pub(super) route_drop_queue_full_total: u64,
     pub(super) route_drop_queue_full_base_total: u64,
     pub(super) route_drop_queue_full_high_total: u64,
-    pub(super) d2c_batches_total: u64,
-    pub(super) d2c_batch_frames_total: u64,
-    pub(super) d2c_batch_bytes_total: u64,
-    pub(super) d2c_flush_reason_queue_drain_total: u64,
-    pub(super) d2c_flush_reason_batch_frames_total: u64,
-    pub(super) d2c_flush_reason_batch_bytes_total: u64,
-    pub(super) d2c_flush_reason_max_delay_total: u64,
-    pub(super) d2c_flush_reason_ack_immediate_total: u64,
-    pub(super) d2c_flush_reason_close_total: u64,
-    pub(super) d2c_data_frames_total: u64,
-    pub(super) d2c_ack_frames_total: u64,
-    pub(super) d2c_payload_bytes_total: u64,
-    pub(super) d2c_write_mode_coalesced_total: u64,
-    pub(super) d2c_write_mode_split_total: u64,
-    pub(super) d2c_quota_reject_pre_write_total: u64,
-    pub(super) d2c_quota_reject_post_write_total: u64,
-    pub(super) d2c_frame_buf_shrink_total: u64,
-    pub(super) d2c_frame_buf_shrink_bytes_total: u64,
     pub(super) socks_kdf_strict_reject_total: u64,
     pub(super) socks_kdf_compat_fallback_total: u64,
     pub(super) endpoint_quarantine_total: u64,
@@ -268,8 +236,6 @@ pub(super) struct MeWritersSummary {
     pub(super) required_writers: usize,
     pub(super) alive_writers: usize,
     pub(super) coverage_pct: f64,
-    pub(super) fresh_alive_writers: usize,
-    pub(super) fresh_coverage_pct: f64,
 }
 
 #[derive(Serialize, Clone)]
@@ -284,12 +250,6 @@ pub(super) struct MeWriterStatus {
     pub(super) bound_clients: usize,
     pub(super) idle_for_secs: Option<u64>,
     pub(super) rtt_ema_ms: Option<f64>,
-    pub(super) matches_active_generation: bool,
-    pub(super) in_desired_map: bool,
-    pub(super) allow_drain_fallback: bool,
-    pub(super) drain_started_at_epoch_secs: Option<u64>,
-    pub(super) drain_deadline_epoch_secs: Option<u64>,
-    pub(super) drain_over_ttl: bool,
 }
 
 #[derive(Serialize, Clone)]
@@ -316,8 +276,6 @@ pub(super) struct DcStatus {
     pub(super) floor_capped: bool,
     pub(super) alive_writers: usize,
     pub(super) coverage_pct: f64,
-    pub(super) fresh_alive_writers: usize,
-    pub(super) fresh_coverage_pct: f64,
     pub(super) rtt_ms: Option<f64>,
     pub(super) load: usize,
 }
@@ -439,7 +397,6 @@ pub(super) struct UserLinks {
 #[derive(Serialize)]
 pub(super) struct UserInfo {
     pub(super) username: String,
-    pub(super) in_runtime: bool,
     pub(super) user_ad_tag: Option<String>,
     pub(super) max_tcp_conns: Option<usize>,
     pub(super) expiration_rfc3339: Option<String>,
@@ -454,24 +411,12 @@ pub(super) struct UserInfo {
     pub(super) links: UserLinks,
 }
 
-#[derive(Serialize)]
-pub(super) struct UserActiveIps {
-    pub(super) username: String,
-    pub(super) active_ips: Vec<IpAddr>,
-}
-
 #[derive(Serialize)]
 pub(super) struct CreateUserResponse {
     pub(super) user: UserInfo,
     pub(super) secret: String,
 }
 
-#[derive(Serialize)]
-pub(super) struct DeleteUserResponse {
-    pub(super) username: String,
-    pub(super) in_runtime: bool,
-}
-
 #[derive(Deserialize)]
 pub(super) struct CreateUserRequest {
     pub(super) username: String,
@@ -526,9 +471,7 @@ pub(super) fn is_valid_username(user: &str) -> bool {
 }
 
 pub(super) fn random_user_secret() -> String {
-    static API_SECRET_RNG: OnceLock<SecureRandom> = OnceLock::new();
-    let rng = API_SECRET_RNG.get_or_init(SecureRandom::new);
     let mut bytes = [0u8; 16];
-    rng.fill(&mut bytes);
+    rand::rng().fill(&mut bytes);
     hex::encode(bytes)
 }

src/api/runtime_init.rs

@@ -167,7 +167,11 @@ async fn current_me_pool_stage_progress(shared: &ApiShared) -> Option<f64> {
     let pool = shared.me_pool.read().await.clone()?;
     let status = pool.api_status_snapshot().await;
     let configured_dc_groups = status.configured_dc_groups;
-    let covered_dc_groups = status.dcs.iter().filter(|dc| dc.alive_writers > 0).count();
+    let covered_dc_groups = status
+        .dcs
+        .iter()
+        .filter(|dc| dc.alive_writers > 0)
+        .count();
 
     let dc_coverage = ratio_01(covered_dc_groups, configured_dc_groups);
     let writer_coverage = ratio_01(status.alive_writers, status.required_writers);

src/api/runtime_min.rs

@@ -107,25 +107,6 @@ pub(super) struct RuntimeMeQualityRouteDropData {
     pub(super) queue_full_high_total: u64,
 }
 
-#[derive(Serialize)]
-pub(super) struct RuntimeMeQualityFamilyStateData {
-    pub(super) family: &'static str,
-    pub(super) state: &'static str,
-    pub(super) state_since_epoch_secs: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) suppressed_until_epoch_secs: Option<u64>,
-    pub(super) fail_streak: u32,
-    pub(super) recover_success_streak: u32,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeQualityDrainGateData {
-    pub(super) route_quorum_ok: bool,
-    pub(super) redundancy_ok: bool,
-    pub(super) block_reason: &'static str,
-    pub(super) updated_at_epoch_secs: u64,
-}
-
 #[derive(Serialize)]
 pub(super) struct RuntimeMeQualityDcRttData {
     pub(super) dc: i16,
@@ -139,8 +120,6 @@ pub(super) struct RuntimeMeQualityDcRttData {
 pub(super) struct RuntimeMeQualityPayload {
     pub(super) counters: RuntimeMeQualityCountersData,
     pub(super) route_drops: RuntimeMeQualityRouteDropData,
-    pub(super) family_states: Vec<RuntimeMeQualityFamilyStateData>,
-    pub(super) drain_gate: RuntimeMeQualityDrainGateData,
     pub(super) dc_rtt: Vec<RuntimeMeQualityDcRttData>,
 }
 
@@ -179,7 +158,6 @@ pub(super) struct RuntimeUpstreamQualitySummaryData {
     pub(super) direct_total: usize,
     pub(super) socks4_total: usize,
     pub(super) socks5_total: usize,
-    pub(super) shadowsocks_total: usize,
 }
 
 #[derive(Serialize)]
@@ -382,19 +360,6 @@ pub(super) async fn build_runtime_me_quality_data(shared: &ApiShared) -> Runtime
     };
 
     let status = pool.api_status_snapshot().await;
-    let family_states = pool
-        .api_family_state_snapshot()
-        .into_iter()
-        .map(|entry| RuntimeMeQualityFamilyStateData {
-            family: entry.family,
-            state: entry.state,
-            state_since_epoch_secs: entry.state_since_epoch_secs,
-            suppressed_until_epoch_secs: entry.suppressed_until_epoch_secs,
-            fail_streak: entry.fail_streak,
-            recover_success_streak: entry.recover_success_streak,
-        })
-        .collect();
-    let drain_gate_snapshot = pool.api_drain_gate_snapshot();
     RuntimeMeQualityData {
         enabled: true,
         reason: None,
@@ -415,13 +380,6 @@ pub(super) async fn build_runtime_me_quality_data(shared: &ApiShared) -> Runtime
                 queue_full_base_total: shared.stats.get_me_route_drop_queue_full_base(),
                 queue_full_high_total: shared.stats.get_me_route_drop_queue_full_high(),
             },
-            family_states,
-            drain_gate: RuntimeMeQualityDrainGateData {
-                route_quorum_ok: drain_gate_snapshot.route_quorum_ok,
-                redundancy_ok: drain_gate_snapshot.redundancy_ok,
-                block_reason: drain_gate_snapshot.block_reason,
-                updated_at_epoch_secs: drain_gate_snapshot.updated_at_epoch_secs,
-            },
             dc_rtt: status
                 .dcs
                 .into_iter()
@@ -446,9 +404,7 @@ pub(super) async fn build_runtime_upstream_quality_data(
         connect_attempt_total: shared.stats.get_upstream_connect_attempt_total(),
         connect_success_total: shared.stats.get_upstream_connect_success_total(),
         connect_fail_total: shared.stats.get_upstream_connect_fail_total(),
-        connect_failfast_hard_error_total: shared
-            .stats
-            .get_upstream_connect_failfast_hard_error_total(),
+        connect_failfast_hard_error_total: shared.stats.get_upstream_connect_failfast_hard_error_total(),
     };
 
     let Some(snapshot) = shared.upstream_manager.try_api_snapshot() else {
@@ -488,7 +444,6 @@ pub(super) async fn build_runtime_upstream_quality_data(
             direct_total: snapshot.summary.direct_total,
             socks4_total: snapshot.summary.socks4_total,
             socks5_total: snapshot.summary.socks5_total,
-            shadowsocks_total: snapshot.summary.shadowsocks_total,
         }),
         upstreams: Some(
             snapshot
@@ -500,7 +455,6 @@ pub(super) async fn build_runtime_upstream_quality_data(
                         crate::transport::UpstreamRouteKind::Direct => "direct",
                         crate::transport::UpstreamRouteKind::Socks4 => "socks4",
                         crate::transport::UpstreamRouteKind::Socks5 => "socks5",
-                        crate::transport::UpstreamRouteKind::Shadowsocks => "shadowsocks",
                     },
                     address: upstream.address,
                     weight: upstream.weight,
@@ -520,9 +474,7 @@ pub(super) async fn build_runtime_upstream_quality_data(
                                 crate::transport::upstream::IpPreference::PreferV6 => "prefer_v6",
                                 crate::transport::upstream::IpPreference::PreferV4 => "prefer_v4",
                                 crate::transport::upstream::IpPreference::BothWork => "both_work",
-                                crate::transport::upstream::IpPreference::Unavailable => {
-                                    "unavailable"
-                                }
+                                crate::transport::upstream::IpPreference::Unavailable => "unavailable",
                             },
                         })
                         .collect(),
@@ -560,15 +512,11 @@ pub(super) async fn build_runtime_nat_stun_data(shared: &ApiShared) -> RuntimeNa
                 live_total: snapshot.live_servers.len(),
             },
             reflection: RuntimeNatStunReflectionBlockData {
-                v4: snapshot
-                    .reflection_v4
-                    .map(|entry| RuntimeNatStunReflectionData {
+                v4: snapshot.reflection_v4.map(|entry| RuntimeNatStunReflectionData {
                     addr: entry.addr.to_string(),
                     age_secs: entry.age_secs,
                 }),
-                v6: snapshot
-                    .reflection_v6
-                    .map(|entry| RuntimeNatStunReflectionData {
+                v6: snapshot.reflection_v6.map(|entry| RuntimeNatStunReflectionData {
                     addr: entry.addr.to_string(),
                     age_secs: entry.age_secs,
                 }),

src/api/runtime_selftest.rs

@@ -1,300 +0,0 @@
-use std::collections::HashMap;
-use std::net::IpAddr;
-use std::sync::{Mutex, OnceLock};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::Serialize;
-
-use crate::config::{ProxyConfig, UpstreamType};
-use crate::network::probe::{detect_interface_ipv4, detect_interface_ipv6, is_bogon};
-use crate::transport::UpstreamRouteKind;
-use crate::transport::middle_proxy::{bnd_snapshot, timeskew_snapshot, upstream_bnd_snapshots};
-
-use super::ApiShared;
-
-const SOURCE_UNAVAILABLE_REASON: &str = "source_unavailable";
-const KDF_EWMA_TAU_SECS: f64 = 600.0;
-const KDF_EWMA_THRESHOLD_ERRORS_PER_MIN: f64 = 0.30;
-const TIMESKEW_THRESHOLD_SECS: u64 = 60;
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestKdfData {
-    pub(super) state: &'static str,
-    pub(super) ewma_errors_per_min: f64,
-    pub(super) threshold_errors_per_min: f64,
-    pub(super) errors_total: u64,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestTimeskewData {
-    pub(super) state: &'static str,
-    pub(super) max_skew_secs_15m: Option<u64>,
-    pub(super) samples_15m: usize,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) last_skew_secs: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) last_source: Option<&'static str>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) last_seen_age_secs: Option<u64>,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestIpFamilyData {
-    pub(super) addr: String,
-    pub(super) state: &'static str,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestIpData {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) v4: Option<RuntimeMeSelftestIpFamilyData>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) v6: Option<RuntimeMeSelftestIpFamilyData>,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestPidData {
-    pub(super) pid: u32,
-    pub(super) state: &'static str,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestBndData {
-    pub(super) addr_state: &'static str,
-    pub(super) port_state: &'static str,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) last_addr: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) last_seen_age_secs: Option<u64>,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestUpstreamData {
-    pub(super) upstream_id: usize,
-    pub(super) route_kind: &'static str,
-    pub(super) address: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) bnd: Option<RuntimeMeSelftestBndData>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) ip: Option<String>,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestPayload {
-    pub(super) kdf: RuntimeMeSelftestKdfData,
-    pub(super) timeskew: RuntimeMeSelftestTimeskewData,
-    pub(super) ip: RuntimeMeSelftestIpData,
-    pub(super) pid: RuntimeMeSelftestPidData,
-    pub(super) bnd: Option<RuntimeMeSelftestBndData>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) upstreams: Option<Vec<RuntimeMeSelftestUpstreamData>>,
-}
-
-#[derive(Serialize)]
-pub(super) struct RuntimeMeSelftestData {
-    pub(super) enabled: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) reason: Option<&'static str>,
-    pub(super) generated_at_epoch_secs: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) data: Option<RuntimeMeSelftestPayload>,
-}
-
-#[derive(Default)]
-struct KdfEwmaState {
-    initialized: bool,
-    last_epoch_secs: u64,
-    last_total_errors: u64,
-    ewma_errors_per_min: f64,
-}
-
-static KDF_EWMA_STATE: OnceLock<Mutex<KdfEwmaState>> = OnceLock::new();
-
-fn kdf_ewma_state() -> &'static Mutex<KdfEwmaState> {
-    KDF_EWMA_STATE.get_or_init(|| Mutex::new(KdfEwmaState::default()))
-}
-
-pub(super) async fn build_runtime_me_selftest_data(
-    shared: &ApiShared,
-    cfg: &ProxyConfig,
-) -> RuntimeMeSelftestData {
-    let now_epoch_secs = now_epoch_secs();
-    if shared.me_pool.read().await.is_none() {
-        return RuntimeMeSelftestData {
-            enabled: false,
-            reason: Some(SOURCE_UNAVAILABLE_REASON),
-            generated_at_epoch_secs: now_epoch_secs,
-            data: None,
-        };
-    }
-
-    let kdf_errors_total = shared
-        .stats
-        .get_me_kdf_drift_total()
-        .saturating_add(shared.stats.get_me_socks_kdf_strict_reject());
-    let kdf_ewma = update_kdf_ewma(now_epoch_secs, kdf_errors_total);
-    let kdf_state = if kdf_ewma >= KDF_EWMA_THRESHOLD_ERRORS_PER_MIN {
-        "error"
-    } else {
-        "ok"
-    };
-
-    let skew = timeskew_snapshot();
-    let timeskew_state = if skew.max_skew_secs_15m.unwrap_or(0) > TIMESKEW_THRESHOLD_SECS {
-        "error"
-    } else {
-        "ok"
-    };
-
-    let ip_v4 = detect_interface_ipv4().map(|ip| RuntimeMeSelftestIpFamilyData {
-        addr: ip.to_string(),
-        state: classify_ip(IpAddr::V4(ip)),
-    });
-    let ip_v6 = detect_interface_ipv6().map(|ip| RuntimeMeSelftestIpFamilyData {
-        addr: ip.to_string(),
-        state: classify_ip(IpAddr::V6(ip)),
-    });
-
-    let pid = std::process::id();
-    let pid_state = if pid == 1 { "one" } else { "non-one" };
-
-    let has_socks_upstreams = cfg.upstreams.iter().any(|upstream| {
-        upstream.enabled
-            && matches!(
-                upstream.upstream_type,
-                UpstreamType::Socks4 { .. } | UpstreamType::Socks5 { .. }
-            )
-    });
-
-    let bnd = if has_socks_upstreams {
-        let snapshot = bnd_snapshot();
-        Some(RuntimeMeSelftestBndData {
-            addr_state: snapshot.addr_status,
-            port_state: snapshot.port_status,
-            last_addr: snapshot.last_addr.map(|value| value.to_string()),
-            last_seen_age_secs: snapshot.last_seen_age_secs,
-        })
-    } else {
-        None
-    };
-    let upstreams = build_upstream_selftest_data(shared);
-
-    RuntimeMeSelftestData {
-        enabled: true,
-        reason: None,
-        generated_at_epoch_secs: now_epoch_secs,
-        data: Some(RuntimeMeSelftestPayload {
-            kdf: RuntimeMeSelftestKdfData {
-                state: kdf_state,
-                ewma_errors_per_min: round3(kdf_ewma),
-                threshold_errors_per_min: KDF_EWMA_THRESHOLD_ERRORS_PER_MIN,
-                errors_total: kdf_errors_total,
-            },
-            timeskew: RuntimeMeSelftestTimeskewData {
-                state: timeskew_state,
-                max_skew_secs_15m: skew.max_skew_secs_15m,
-                samples_15m: skew.samples_15m,
-                last_skew_secs: skew.last_skew_secs,
-                last_source: skew.last_source,
-                last_seen_age_secs: skew.last_seen_age_secs,
-            },
-            ip: RuntimeMeSelftestIpData {
-                v4: ip_v4,
-                v6: ip_v6,
-            },
-            pid: RuntimeMeSelftestPidData {
-                pid,
-                state: pid_state,
-            },
-            bnd,
-            upstreams,
-        }),
-    }
-}
-
-fn build_upstream_selftest_data(shared: &ApiShared) -> Option<Vec<RuntimeMeSelftestUpstreamData>> {
-    let snapshot = shared.upstream_manager.try_api_snapshot()?;
-    if snapshot.summary.configured_total <= 1 {
-        return None;
-    }
-
-    let mut upstream_bnd_by_id: HashMap<usize, _> = upstream_bnd_snapshots()
-        .into_iter()
-        .map(|entry| (entry.upstream_id, entry))
-        .collect();
-    let mut rows = Vec::with_capacity(snapshot.upstreams.len());
-    for upstream in snapshot.upstreams {
-        let upstream_bnd = upstream_bnd_by_id.remove(&upstream.upstream_id);
-        rows.push(RuntimeMeSelftestUpstreamData {
-            upstream_id: upstream.upstream_id,
-            route_kind: map_route_kind(upstream.route_kind),
-            address: upstream.address,
-            bnd: upstream_bnd.as_ref().map(|entry| RuntimeMeSelftestBndData {
-                addr_state: entry.addr_status,
-                port_state: entry.port_status,
-                last_addr: entry.last_addr.map(|value| value.to_string()),
-                last_seen_age_secs: entry.last_seen_age_secs,
-            }),
-            ip: upstream_bnd.and_then(|entry| entry.last_ip.map(|value| value.to_string())),
-        });
-    }
-    Some(rows)
-}
-
-fn update_kdf_ewma(now_epoch_secs: u64, total_errors: u64) -> f64 {
-    let Ok(mut guard) = kdf_ewma_state().lock() else {
-        return 0.0;
-    };
-
-    if !guard.initialized {
-        guard.initialized = true;
-        guard.last_epoch_secs = now_epoch_secs;
-        guard.last_total_errors = total_errors;
-        guard.ewma_errors_per_min = 0.0;
-        return guard.ewma_errors_per_min;
-    }
-
-    let dt_secs = now_epoch_secs.saturating_sub(guard.last_epoch_secs);
-    if dt_secs == 0 {
-        return guard.ewma_errors_per_min;
-    }
-
-    let delta_errors = total_errors.saturating_sub(guard.last_total_errors);
-    let instant_rate_per_min = (delta_errors as f64) * 60.0 / (dt_secs as f64);
-    let alpha = 1.0 - f64::exp(-(dt_secs as f64) / KDF_EWMA_TAU_SECS);
-    guard.ewma_errors_per_min =
-        guard.ewma_errors_per_min + alpha * (instant_rate_per_min - guard.ewma_errors_per_min);
-    guard.last_epoch_secs = now_epoch_secs;
-    guard.last_total_errors = total_errors;
-    guard.ewma_errors_per_min
-}
-
-fn classify_ip(ip: IpAddr) -> &'static str {
-    if ip.is_loopback() {
-        return "loopback";
-    }
-    if is_bogon(ip) {
-        return "bogon";
-    }
-    "good"
-}
-
-fn map_route_kind(value: UpstreamRouteKind) -> &'static str {
-    match value {
-        UpstreamRouteKind::Direct => "direct",
-        UpstreamRouteKind::Socks4 => "socks4",
-        UpstreamRouteKind::Socks5 => "socks5",
-        UpstreamRouteKind::Shadowsocks => "shadowsocks",
-    }
-}
-
-fn round3(value: f64) -> f64 {
-    (value * 1000.0).round() / 1000.0
-}
-
-fn now_epoch_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs()
-}

src/api/runtime_stats.rs

@@ -2,8 +2,8 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use crate::config::ApiConfig;
 use crate::stats::Stats;
-use crate::transport::UpstreamRouteKind;
 use crate::transport::upstream::IpPreference;
+use crate::transport::UpstreamRouteKind;
 
 use super::ApiShared;
 use super::model::{
@@ -39,21 +39,10 @@ pub(super) fn build_zero_all_data(stats: &Stats, configured_users: usize) -> Zer
             connections_total: stats.get_connects_all(),
             connections_bad_total: stats.get_connects_bad(),
             handshake_timeouts_total: stats.get_handshake_timeouts(),
-            accept_permit_timeout_total: stats.get_accept_permit_timeout_total(),
             configured_users,
             telemetry_core_enabled: telemetry.core_enabled,
             telemetry_user_enabled: telemetry.user_enabled,
             telemetry_me_level: telemetry.me_level.to_string(),
-            conntrack_control_enabled: stats.get_conntrack_control_enabled(),
-            conntrack_control_available: stats.get_conntrack_control_available(),
-            conntrack_pressure_active: stats.get_conntrack_pressure_active(),
-            conntrack_event_queue_depth: stats.get_conntrack_event_queue_depth(),
-            conntrack_rule_apply_ok: stats.get_conntrack_rule_apply_ok(),
-            conntrack_delete_attempt_total: stats.get_conntrack_delete_attempt_total(),
-            conntrack_delete_success_total: stats.get_conntrack_delete_success_total(),
-            conntrack_delete_not_found_total: stats.get_conntrack_delete_not_found_total(),
-            conntrack_delete_error_total: stats.get_conntrack_delete_error_total(),
-            conntrack_close_event_drop_total: stats.get_conntrack_close_event_drop_total(),
         },
         upstream: build_zero_upstream_data(stats),
         middle_proxy: ZeroMiddleProxyData {
@@ -79,25 +68,6 @@ pub(super) fn build_zero_all_data(stats: &Stats, configured_users: usize) -> Zer
             route_drop_queue_full_total: stats.get_me_route_drop_queue_full(),
             route_drop_queue_full_base_total: stats.get_me_route_drop_queue_full_base(),
             route_drop_queue_full_high_total: stats.get_me_route_drop_queue_full_high(),
-            d2c_batches_total: stats.get_me_d2c_batches_total(),
-            d2c_batch_frames_total: stats.get_me_d2c_batch_frames_total(),
-            d2c_batch_bytes_total: stats.get_me_d2c_batch_bytes_total(),
-            d2c_flush_reason_queue_drain_total: stats.get_me_d2c_flush_reason_queue_drain_total(),
-            d2c_flush_reason_batch_frames_total: stats.get_me_d2c_flush_reason_batch_frames_total(),
-            d2c_flush_reason_batch_bytes_total: stats.get_me_d2c_flush_reason_batch_bytes_total(),
-            d2c_flush_reason_max_delay_total: stats.get_me_d2c_flush_reason_max_delay_total(),
-            d2c_flush_reason_ack_immediate_total: stats
-                .get_me_d2c_flush_reason_ack_immediate_total(),
-            d2c_flush_reason_close_total: stats.get_me_d2c_flush_reason_close_total(),
-            d2c_data_frames_total: stats.get_me_d2c_data_frames_total(),
-            d2c_ack_frames_total: stats.get_me_d2c_ack_frames_total(),
-            d2c_payload_bytes_total: stats.get_me_d2c_payload_bytes_total(),
-            d2c_write_mode_coalesced_total: stats.get_me_d2c_write_mode_coalesced_total(),
-            d2c_write_mode_split_total: stats.get_me_d2c_write_mode_split_total(),
-            d2c_quota_reject_pre_write_total: stats.get_me_d2c_quota_reject_pre_write_total(),
-            d2c_quota_reject_post_write_total: stats.get_me_d2c_quota_reject_post_write_total(),
-            d2c_frame_buf_shrink_total: stats.get_me_d2c_frame_buf_shrink_total(),
-            d2c_frame_buf_shrink_bytes_total: stats.get_me_d2c_frame_buf_shrink_bytes_total(),
             socks_kdf_strict_reject_total: stats.get_me_socks_kdf_strict_reject(),
             socks_kdf_compat_fallback_total: stats.get_me_socks_kdf_compat_fallback(),
             endpoint_quarantine_total: stats.get_me_endpoint_quarantine_total(),
@@ -166,8 +136,7 @@ fn build_zero_upstream_data(stats: &Stats) -> ZeroUpstreamData {
             .get_upstream_connect_duration_success_bucket_501_1000ms(),
         connect_duration_success_bucket_gt_1000ms: stats
             .get_upstream_connect_duration_success_bucket_gt_1000ms(),
-        connect_duration_fail_bucket_le_100ms: stats
-            .get_upstream_connect_duration_fail_bucket_le_100ms(),
+        connect_duration_fail_bucket_le_100ms: stats.get_upstream_connect_duration_fail_bucket_le_100ms(),
         connect_duration_fail_bucket_101_500ms: stats
             .get_upstream_connect_duration_fail_bucket_101_500ms(),
         connect_duration_fail_bucket_501_1000ms: stats
@@ -209,7 +178,6 @@ pub(super) fn build_upstreams_data(shared: &ApiShared, api_cfg: &ApiConfig) -> U
         direct_total: snapshot.summary.direct_total,
         socks4_total: snapshot.summary.socks4_total,
         socks5_total: snapshot.summary.socks5_total,
-        shadowsocks_total: snapshot.summary.shadowsocks_total,
     };
     let upstreams = snapshot
         .upstreams
@@ -346,8 +314,6 @@ async fn get_minimal_payload_cached(
             required_writers: status.required_writers,
             alive_writers: status.alive_writers,
             coverage_pct: status.coverage_pct,
-            fresh_alive_writers: status.fresh_alive_writers,
-            fresh_coverage_pct: status.fresh_coverage_pct,
         },
         writers: status
             .writers
@@ -363,12 +329,6 @@ async fn get_minimal_payload_cached(
                 bound_clients: entry.bound_clients,
                 idle_for_secs: entry.idle_for_secs,
                 rtt_ema_ms: entry.rtt_ema_ms,
-                matches_active_generation: entry.matches_active_generation,
-                in_desired_map: entry.in_desired_map,
-                allow_drain_fallback: entry.allow_drain_fallback,
-                drain_started_at_epoch_secs: entry.drain_started_at_epoch_secs,
-                drain_deadline_epoch_secs: entry.drain_deadline_epoch_secs,
-                drain_over_ttl: entry.drain_over_ttl,
             })
             .collect(),
     };
@@ -403,8 +363,6 @@ async fn get_minimal_payload_cached(
                 floor_capped: entry.floor_capped,
                 alive_writers: entry.alive_writers,
                 coverage_pct: entry.coverage_pct,
-                fresh_alive_writers: entry.fresh_alive_writers,
-                fresh_coverage_pct: entry.fresh_coverage_pct,
                 rtt_ms: entry.rtt_ms,
                 load: entry.load,
             })
@@ -423,7 +381,8 @@ async fn get_minimal_payload_cached(
         adaptive_floor_min_writers_multi_endpoint: runtime
             .adaptive_floor_min_writers_multi_endpoint,
         adaptive_floor_recover_grace_secs: runtime.adaptive_floor_recover_grace_secs,
-        adaptive_floor_writers_per_core_total: runtime.adaptive_floor_writers_per_core_total,
+        adaptive_floor_writers_per_core_total: runtime
+            .adaptive_floor_writers_per_core_total,
         adaptive_floor_cpu_cores_override: runtime.adaptive_floor_cpu_cores_override,
         adaptive_floor_max_extra_writers_single_per_core: runtime
             .adaptive_floor_max_extra_writers_single_per_core,
@@ -431,9 +390,12 @@ async fn get_minimal_payload_cached(
             .adaptive_floor_max_extra_writers_multi_per_core,
         adaptive_floor_max_active_writers_per_core: runtime
             .adaptive_floor_max_active_writers_per_core,
-        adaptive_floor_max_warm_writers_per_core: runtime.adaptive_floor_max_warm_writers_per_core,
-        adaptive_floor_max_active_writers_global: runtime.adaptive_floor_max_active_writers_global,
-        adaptive_floor_max_warm_writers_global: runtime.adaptive_floor_max_warm_writers_global,
+        adaptive_floor_max_warm_writers_per_core: runtime
+            .adaptive_floor_max_warm_writers_per_core,
+        adaptive_floor_max_active_writers_global: runtime
+            .adaptive_floor_max_active_writers_global,
+        adaptive_floor_max_warm_writers_global: runtime
+            .adaptive_floor_max_warm_writers_global,
         adaptive_floor_cpu_cores_detected: runtime.adaptive_floor_cpu_cores_detected,
         adaptive_floor_cpu_cores_effective: runtime.adaptive_floor_cpu_cores_effective,
         adaptive_floor_global_cap_raw: runtime.adaptive_floor_global_cap_raw,
@@ -524,8 +486,6 @@ fn disabled_me_writers(now_epoch_secs: u64, reason: &'static str) -> MeWritersDa
             required_writers: 0,
             alive_writers: 0,
             coverage_pct: 0.0,
-            fresh_alive_writers: 0,
-            fresh_coverage_pct: 0.0,
         },
         writers: Vec::new(),
     }
@@ -545,7 +505,6 @@ fn map_route_kind(value: UpstreamRouteKind) -> &'static str {
         UpstreamRouteKind::Direct => "direct",
         UpstreamRouteKind::Socks4 => "socks4",
         UpstreamRouteKind::Socks5 => "socks5",
-        UpstreamRouteKind::Shadowsocks => "shadowsocks",
     }
 }
 

src/api/runtime_zero.rs

@@ -3,7 +3,6 @@ use std::sync::atomic::Ordering;
 use serde::Serialize;
 
 use crate::config::{MeFloorMode, MeWriterPickMode, ProxyConfig, UserMaxUniqueIpsMode};
-use crate::proxy::route_mode::RelayRouteMode;
 
 use super::ApiShared;
 use super::runtime_init::build_runtime_startup_summary;
@@ -35,14 +34,7 @@ pub(super) struct RuntimeGatesData {
     pub(super) conditional_cast_enabled: bool,
     pub(super) me_runtime_ready: bool,
     pub(super) me2dc_fallback_enabled: bool,
-    pub(super) me2dc_fast_enabled: bool,
     pub(super) use_middle_proxy: bool,
-    pub(super) route_mode: &'static str,
-    pub(super) reroute_active: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) reroute_to_direct_at_epoch_secs: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(super) reroute_reason: Option<&'static str>,
     pub(super) startup_status: &'static str,
     pub(super) startup_stage: String,
     pub(super) startup_progress_pct: f64,
@@ -50,7 +42,6 @@ pub(super) struct RuntimeGatesData {
 
 #[derive(Serialize)]
 pub(super) struct EffectiveTimeoutLimits {
-    pub(super) client_first_byte_idle_secs: u64,
     pub(super) client_handshake_secs: u64,
     pub(super) tg_connect_secs: u64,
     pub(super) client_keepalive_secs: u64,
@@ -90,21 +81,14 @@ pub(super) struct EffectiveMiddleProxyLimits {
     pub(super) writer_pick_mode: &'static str,
     pub(super) writer_pick_sample_size: u8,
     pub(super) me2dc_fallback: bool,
-    pub(super) me2dc_fast: bool,
 }
 
 #[derive(Serialize)]
 pub(super) struct EffectiveUserIpPolicyLimits {
-    pub(super) global_each: usize,
     pub(super) mode: &'static str,
     pub(super) window_secs: u64,
 }
 
-#[derive(Serialize)]
-pub(super) struct EffectiveUserTcpPolicyLimits {
-    pub(super) global_each: usize,
-}
-
 #[derive(Serialize)]
 pub(super) struct EffectiveLimitsData {
     pub(super) update_every_secs: u64,
@@ -114,7 +98,6 @@ pub(super) struct EffectiveLimitsData {
     pub(super) upstream: EffectiveUpstreamLimits,
     pub(super) middle_proxy: EffectiveMiddleProxyLimits,
     pub(super) user_ip_policy: EffectiveUserIpPolicyLimits,
-    pub(super) user_tcp_policy: EffectiveUserTcpPolicyLimits,
 }
 
 #[derive(Serialize)]
@@ -139,8 +122,7 @@ pub(super) fn build_system_info_data(
         .runtime_state
         .last_config_reload_epoch_secs
         .load(Ordering::Relaxed);
-    let last_config_reload_epoch_secs =
-        (last_reload_epoch_secs > 0).then_some(last_reload_epoch_secs);
+    let last_config_reload_epoch_secs = (last_reload_epoch_secs > 0).then_some(last_reload_epoch_secs);
 
     let git_commit = option_env!("TELEMT_GIT_COMMIT")
         .or(option_env!("VERGEN_GIT_SHA"))
@@ -165,10 +147,7 @@ pub(super) fn build_system_info_data(
         uptime_seconds: shared.stats.uptime_secs(),
         config_path: shared.config_path.display().to_string(),
         config_hash: revision.to_string(),
-        config_reload_count: shared
-            .runtime_state
-            .config_reload_count
-            .load(Ordering::Relaxed),
+        config_reload_count: shared.runtime_state.config_reload_count.load(Ordering::Relaxed),
         last_config_reload_epoch_secs,
     }
 }
@@ -178,27 +157,6 @@ pub(super) async fn build_runtime_gates_data(
     cfg: &ProxyConfig,
 ) -> RuntimeGatesData {
     let startup_summary = build_runtime_startup_summary(shared).await;
-    let route_state = shared.route_runtime.snapshot();
-    let route_mode = route_state.mode.as_str();
-    let fast_fallback_enabled =
-        cfg.general.use_middle_proxy && cfg.general.me2dc_fallback && cfg.general.me2dc_fast;
-    let reroute_active = cfg.general.use_middle_proxy
-        && cfg.general.me2dc_fallback
-        && matches!(route_state.mode, RelayRouteMode::Direct);
-    let reroute_to_direct_at_epoch_secs = if reroute_active {
-        shared.route_runtime.direct_since_epoch_secs()
-    } else {
-        None
-    };
-    let reroute_reason = if reroute_active {
-        if fast_fallback_enabled {
-            Some("fast_not_ready_fallback")
-        } else {
-            Some("strict_grace_fallback")
-        }
-    } else {
-        None
-    };
     let me_runtime_ready = if !cfg.general.use_middle_proxy {
         true
     } else {
@@ -216,12 +174,7 @@ pub(super) async fn build_runtime_gates_data(
         conditional_cast_enabled: cfg.general.use_middle_proxy,
         me_runtime_ready,
         me2dc_fallback_enabled: cfg.general.me2dc_fallback,
-        me2dc_fast_enabled: fast_fallback_enabled,
         use_middle_proxy: cfg.general.use_middle_proxy,
-        route_mode,
-        reroute_active,
-        reroute_to_direct_at_epoch_secs,
-        reroute_reason,
         startup_status: startup_summary.status,
         startup_stage: startup_summary.stage,
         startup_progress_pct: startup_summary.progress_pct,
@@ -234,9 +187,8 @@ pub(super) fn build_limits_effective_data(cfg: &ProxyConfig) -> EffectiveLimitsD
         me_reinit_every_secs: cfg.general.effective_me_reinit_every_secs(),
         me_pool_force_close_secs: cfg.general.effective_me_pool_force_close_secs(),
         timeouts: EffectiveTimeoutLimits {
-            client_first_byte_idle_secs: cfg.timeouts.client_first_byte_idle_secs,
             client_handshake_secs: cfg.timeouts.client_handshake,
-            tg_connect_secs: cfg.general.tg_connect,
+            tg_connect_secs: cfg.timeouts.tg_connect,
             client_keepalive_secs: cfg.timeouts.client_keepalive,
             client_ack_secs: cfg.timeouts.client_ack,
             me_one_retry: cfg.timeouts.me_one_retry,
@@ -262,7 +214,9 @@ pub(super) fn build_limits_effective_data(cfg: &ProxyConfig) -> EffectiveLimitsD
             adaptive_floor_writers_per_core_total: cfg
                 .general
                 .me_adaptive_floor_writers_per_core_total,
-            adaptive_floor_cpu_cores_override: cfg.general.me_adaptive_floor_cpu_cores_override,
+            adaptive_floor_cpu_cores_override: cfg
+                .general
+                .me_adaptive_floor_cpu_cores_override,
             adaptive_floor_max_extra_writers_single_per_core: cfg
                 .general
                 .me_adaptive_floor_max_extra_writers_single_per_core,
@@ -288,16 +242,11 @@ pub(super) fn build_limits_effective_data(cfg: &ProxyConfig) -> EffectiveLimitsD
             writer_pick_mode: me_writer_pick_mode_label(cfg.general.me_writer_pick_mode),
             writer_pick_sample_size: cfg.general.me_writer_pick_sample_size,
             me2dc_fallback: cfg.general.me2dc_fallback,
-            me2dc_fast: cfg.general.me2dc_fast,
         },
         user_ip_policy: EffectiveUserIpPolicyLimits {
-            global_each: cfg.access.user_max_unique_ips_global_each,
             mode: user_max_unique_ips_mode_label(cfg.access.user_max_unique_ips_mode),
             window_secs: cfg.access.user_max_unique_ips_window_secs,
         },
-        user_tcp_policy: EffectiveUserTcpPolicyLimits {
-            global_each: cfg.access.user_max_tcp_conns_global_each,
-        },
     }
 }
 

src/api/users.rs

@@ -8,8 +8,7 @@ use crate::stats::Stats;
 
 use super::ApiShared;
 use super::config_store::{
-    AccessSection, ensure_expected_revision, load_config_from_disk, save_access_sections_to_disk,
-    save_config_to_disk,
+    ensure_expected_revision, load_config_from_disk, save_config_to_disk,
 };
 use super::model::{
     ApiFailure, CreateUserRequest, CreateUserResponse, PatchUserRequest, RotateSecretRequest,
@@ -22,12 +21,6 @@ pub(super) async fn create_user(
     expected_revision: Option<String>,
     shared: &ApiShared,
 ) -> Result<(CreateUserResponse, String), ApiFailure> {
-    let touches_user_ad_tags = body.user_ad_tag.is_some();
-    let touches_user_max_tcp_conns = body.max_tcp_conns.is_some();
-    let touches_user_expirations = body.expiration_rfc3339.is_some();
-    let touches_user_data_quota = body.data_quota_bytes.is_some();
-    let touches_user_max_unique_ips = body.max_unique_ips.is_some();
-
     if !is_valid_username(&body.username) {
         return Err(ApiFailure::bad_request(
             "username must match [A-Za-z0-9_.-] and be 1..64 chars",
@@ -46,9 +39,7 @@ pub(super) async fn create_user(
         None => random_user_secret(),
     };
 
-    if let Some(ad_tag) = body.user_ad_tag.as_ref()
-        && !is_valid_ad_tag(ad_tag)
-    {
+    if let Some(ad_tag) = body.user_ad_tag.as_ref() && !is_valid_ad_tag(ad_tag) {
         return Err(ApiFailure::bad_request(
             "user_ad_tag must be exactly 32 hex characters",
         ));
@@ -67,18 +58,12 @@ pub(super) async fn create_user(
         ));
     }
 
-    cfg.access
-        .users
-        .insert(body.username.clone(), secret.clone());
+    cfg.access.users.insert(body.username.clone(), secret.clone());
     if let Some(ad_tag) = body.user_ad_tag {
-        cfg.access
-            .user_ad_tags
-            .insert(body.username.clone(), ad_tag);
+        cfg.access.user_ad_tags.insert(body.username.clone(), ad_tag);
     }
     if let Some(limit) = body.max_tcp_conns {
-        cfg.access
-            .user_max_tcp_conns
-            .insert(body.username.clone(), limit);
+        cfg.access.user_max_tcp_conns.insert(body.username.clone(), limit);
     }
     if let Some(expiration) = expiration {
         cfg.access
@@ -86,9 +71,7 @@ pub(super) async fn create_user(
             .insert(body.username.clone(), expiration);
     }
     if let Some(quota) = body.data_quota_bytes {
-        cfg.access
-            .user_data_quota
-            .insert(body.username.clone(), quota);
+        cfg.access.user_data_quota.insert(body.username.clone(), quota);
     }
 
     let updated_limit = body.max_unique_ips;
@@ -101,42 +84,19 @@ pub(super) async fn create_user(
     cfg.validate()
         .map_err(|e| ApiFailure::bad_request(format!("config validation failed: {}", e)))?;
 
-    let mut touched_sections = vec![AccessSection::Users];
-    if touches_user_ad_tags {
-        touched_sections.push(AccessSection::UserAdTags);
-    }
-    if touches_user_max_tcp_conns {
-        touched_sections.push(AccessSection::UserMaxTcpConns);
-    }
-    if touches_user_expirations {
-        touched_sections.push(AccessSection::UserExpirations);
-    }
-    if touches_user_data_quota {
-        touched_sections.push(AccessSection::UserDataQuota);
-    }
-    if touches_user_max_unique_ips {
-        touched_sections.push(AccessSection::UserMaxUniqueIps);
-    }
-
-    let revision =
-        save_access_sections_to_disk(&shared.config_path, &cfg, &touched_sections).await?;
+    let revision = save_config_to_disk(&shared.config_path, &cfg).await?;
     drop(_guard);
 
     if let Some(limit) = updated_limit {
-        shared
-            .ip_tracker
-            .set_user_limit(&body.username, limit)
-            .await;
+        shared.ip_tracker.set_user_limit(&body.username, limit).await;
     }
-    let (detected_ip_v4, detected_ip_v6) = shared.detected_link_ips();
 
     let users = users_from_config(
         &cfg,
         &shared.stats,
         &shared.ip_tracker,
-        detected_ip_v4,
-        detected_ip_v6,
-        None,
+        shared.startup_detected_ip_v4,
+        shared.startup_detected_ip_v6,
     )
     .await;
     let user = users
@@ -144,16 +104,8 @@ pub(super) async fn create_user(
         .find(|entry| entry.username == body.username)
         .unwrap_or(UserInfo {
             username: body.username.clone(),
-            in_runtime: false,
             user_ad_tag: None,
-            max_tcp_conns: cfg
-                .access
-                .user_max_tcp_conns
-                .get(&body.username)
-                .copied()
-                .filter(|limit| *limit > 0)
-                .or((cfg.access.user_max_tcp_conns_global_each > 0)
-                    .then_some(cfg.access.user_max_tcp_conns_global_each)),
+            max_tcp_conns: None,
             expiration_rfc3339: None,
             data_quota_bytes: None,
             max_unique_ips: updated_limit,
@@ -163,7 +115,12 @@ pub(super) async fn create_user(
             recent_unique_ips: 0,
             recent_unique_ips_list: Vec::new(),
             total_octets: 0,
-            links: build_user_links(&cfg, &secret, detected_ip_v4, detected_ip_v6),
+            links: build_user_links(
+                &cfg,
+                &secret,
+                shared.startup_detected_ip_v4,
+                shared.startup_detected_ip_v6,
+            ),
         });
 
     Ok((CreateUserResponse { user, secret }, revision))
@@ -175,16 +132,12 @@ pub(super) async fn patch_user(
     expected_revision: Option<String>,
     shared: &ApiShared,
 ) -> Result<(UserInfo, String), ApiFailure> {
-    if let Some(secret) = body.secret.as_ref()
-        && !is_valid_user_secret(secret)
-    {
+    if let Some(secret) = body.secret.as_ref() && !is_valid_user_secret(secret) {
         return Err(ApiFailure::bad_request(
             "secret must be exactly 32 hex characters",
         ));
     }
-    if let Some(ad_tag) = body.user_ad_tag.as_ref()
-        && !is_valid_ad_tag(ad_tag)
-    {
+    if let Some(ad_tag) = body.user_ad_tag.as_ref() && !is_valid_ad_tag(ad_tag) {
         return Err(ApiFailure::bad_request(
             "user_ad_tag must be exactly 32 hex characters",
         ));
@@ -209,14 +162,10 @@ pub(super) async fn patch_user(
         cfg.access.user_ad_tags.insert(user.to_string(), ad_tag);
     }
     if let Some(limit) = body.max_tcp_conns {
-        cfg.access
-            .user_max_tcp_conns
-            .insert(user.to_string(), limit);
+        cfg.access.user_max_tcp_conns.insert(user.to_string(), limit);
     }
     if let Some(expiration) = expiration {
-        cfg.access
-            .user_expirations
-            .insert(user.to_string(), expiration);
+        cfg.access.user_expirations.insert(user.to_string(), expiration);
     }
     if let Some(quota) = body.data_quota_bytes {
         cfg.access.user_data_quota.insert(user.to_string(), quota);
@@ -224,9 +173,7 @@ pub(super) async fn patch_user(
 
     let mut updated_limit = None;
     if let Some(limit) = body.max_unique_ips {
-        cfg.access
-            .user_max_unique_ips
-            .insert(user.to_string(), limit);
+        cfg.access.user_max_unique_ips.insert(user.to_string(), limit);
         updated_limit = Some(limit);
     }
 
@@ -238,14 +185,12 @@ pub(super) async fn patch_user(
     if let Some(limit) = updated_limit {
         shared.ip_tracker.set_user_limit(user, limit).await;
     }
-    let (detected_ip_v4, detected_ip_v6) = shared.detected_link_ips();
     let users = users_from_config(
         &cfg,
         &shared.stats,
         &shared.ip_tracker,
-        detected_ip_v4,
-        detected_ip_v6,
-        None,
+        shared.startup_detected_ip_v4,
+        shared.startup_detected_ip_v6,
     )
     .await;
     let user_info = users
@@ -284,26 +229,15 @@ pub(super) async fn rotate_secret(
     cfg.access.users.insert(user.to_string(), secret.clone());
     cfg.validate()
         .map_err(|e| ApiFailure::bad_request(format!("config validation failed: {}", e)))?;
-    let touched_sections = [
-        AccessSection::Users,
-        AccessSection::UserAdTags,
-        AccessSection::UserMaxTcpConns,
-        AccessSection::UserExpirations,
-        AccessSection::UserDataQuota,
-        AccessSection::UserMaxUniqueIps,
-    ];
-    let revision =
-        save_access_sections_to_disk(&shared.config_path, &cfg, &touched_sections).await?;
+    let revision = save_config_to_disk(&shared.config_path, &cfg).await?;
     drop(_guard);
 
-    let (detected_ip_v4, detected_ip_v6) = shared.detected_link_ips();
     let users = users_from_config(
         &cfg,
         &shared.stats,
         &shared.ip_tracker,
-        detected_ip_v4,
-        detected_ip_v6,
-        None,
+        shared.startup_detected_ip_v4,
+        shared.startup_detected_ip_v6,
     )
     .await;
     let user_info = users
@@ -353,16 +287,7 @@ pub(super) async fn delete_user(
 
     cfg.validate()
         .map_err(|e| ApiFailure::bad_request(format!("config validation failed: {}", e)))?;
-    let touched_sections = [
-        AccessSection::Users,
-        AccessSection::UserAdTags,
-        AccessSection::UserMaxTcpConns,
-        AccessSection::UserExpirations,
-        AccessSection::UserDataQuota,
-        AccessSection::UserMaxUniqueIps,
-    ];
-    let revision =
-        save_access_sections_to_disk(&shared.config_path, &cfg, &touched_sections).await?;
+    let revision = save_config_to_disk(&shared.config_path, &cfg).await?;
     drop(_guard);
     shared.ip_tracker.remove_user_limit(user).await;
     shared.ip_tracker.clear_user_ips(user).await;
@@ -376,7 +301,6 @@ pub(super) async fn users_from_config(
     ip_tracker: &UserIpTracker,
     startup_detected_ip_v4: Option<IpAddr>,
     startup_detected_ip_v6: Option<IpAddr>,
-    runtime_cfg: Option<&ProxyConfig>,
 ) -> Vec<UserInfo> {
     let mut names = cfg.access.users.keys().cloned().collect::<Vec<_>>();
     names.sort();
@@ -398,7 +322,12 @@ pub(super) async fn users_from_config(
             .users
             .get(&username)
             .map(|secret| {
-                build_user_links(cfg, secret, startup_detected_ip_v4, startup_detected_ip_v6)
+                build_user_links(
+                    cfg,
+                    secret,
+                    startup_detected_ip_v4,
+                    startup_detected_ip_v6,
+                )
             })
             .unwrap_or(UserLinks {
                 classic: Vec::new(),
@@ -406,32 +335,15 @@ pub(super) async fn users_from_config(
                 tls: Vec::new(),
             });
         users.push(UserInfo {
-            in_runtime: runtime_cfg
-                .map(|runtime| runtime.access.users.contains_key(&username))
-                .unwrap_or(false),
             user_ad_tag: cfg.access.user_ad_tags.get(&username).cloned(),
-            max_tcp_conns: cfg
-                .access
-                .user_max_tcp_conns
-                .get(&username)
-                .copied()
-                .filter(|limit| *limit > 0)
-                .or((cfg.access.user_max_tcp_conns_global_each > 0)
-                    .then_some(cfg.access.user_max_tcp_conns_global_each)),
+            max_tcp_conns: cfg.access.user_max_tcp_conns.get(&username).copied(),
             expiration_rfc3339: cfg
                 .access
                 .user_expirations
                 .get(&username)
                 .map(chrono::DateTime::<chrono::Utc>::to_rfc3339),
             data_quota_bytes: cfg.access.user_data_quota.get(&username).copied(),
-            max_unique_ips: cfg
-                .access
-                .user_max_unique_ips
-                .get(&username)
-                .copied()
-                .filter(|limit| *limit > 0)
-                .or((cfg.access.user_max_unique_ips_global_each > 0)
-                    .then_some(cfg.access.user_max_unique_ips_global_each)),
+            max_unique_ips: cfg.access.user_max_unique_ips.get(&username).copied(),
             current_connections: stats.get_user_curr_connects(&username),
             active_unique_ips: active_ip_list.len(),
             active_unique_ips_list: active_ip_list,
@@ -506,6 +418,17 @@ fn resolve_link_hosts(
         return vec![host.to_string()];
     }
 
+    let mut startup_hosts = Vec::new();
+    if let Some(ip) = startup_detected_ip_v4 {
+        push_unique_host(&mut startup_hosts, &ip.to_string());
+    }
+    if let Some(ip) = startup_detected_ip_v6 {
+        push_unique_host(&mut startup_hosts, &ip.to_string());
+    }
+    if !startup_hosts.is_empty() {
+        return startup_hosts;
+    }
+
     let mut hosts = Vec::new();
     for listener in &cfg.server.listeners {
         if let Some(host) = listener
@@ -517,47 +440,27 @@ fn resolve_link_hosts(
             push_unique_host(&mut hosts, host);
             continue;
         }
-        if let Some(ip) = listener.announce_ip
-            && !ip.is_unspecified()
-        {
+        if let Some(ip) = listener.announce_ip {
+            if !ip.is_unspecified() {
                 push_unique_host(&mut hosts, &ip.to_string());
-            continue;
-        }
-        if listener.ip.is_unspecified() {
-            let detected_ip = if listener.ip.is_ipv4() {
-                startup_detected_ip_v4
-            } else {
-                startup_detected_ip_v6
-            };
-            if let Some(ip) = detected_ip {
-                push_unique_host(&mut hosts, &ip.to_string());
-            } else {
-                push_unique_host(&mut hosts, &listener.ip.to_string());
             }
             continue;
         }
+        if !listener.ip.is_unspecified() {
             push_unique_host(&mut hosts, &listener.ip.to_string());
         }
-
-    if !hosts.is_empty() {
-        return hosts;
-    }
-
-    if let Some(ip) = startup_detected_ip_v4.or(startup_detected_ip_v6) {
-        return vec![ip.to_string()];
     }
 
+    if hosts.is_empty() {
         if let Some(host) = cfg.server.listen_addr_ipv4.as_deref() {
             push_host_from_legacy_listen(&mut hosts, host);
         }
         if let Some(host) = cfg.server.listen_addr_ipv6.as_deref() {
             push_host_from_legacy_listen(&mut hosts, host);
         }
-    if !hosts.is_empty() {
-        return hosts;
     }
 
-    vec!["UNKNOWN".to_string()]
+    hosts
 }
 
 fn push_host_from_legacy_listen(hosts: &mut Vec<String>, raw: &str) {
@@ -594,94 +497,3 @@ fn resolve_tls_domains(cfg: &ProxyConfig) -> Vec<&str> {
     }
     domains
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ip_tracker::UserIpTracker;
-    use crate::stats::Stats;
-
-    #[tokio::test]
-    async fn users_from_config_reports_effective_tcp_limit_with_global_fallback() {
-        let mut cfg = ProxyConfig::default();
-        cfg.access.users.insert(
-            "alice".to_string(),
-            "0123456789abcdef0123456789abcdef".to_string(),
-        );
-        cfg.access.user_max_tcp_conns_global_each = 7;
-
-        let stats = Stats::new();
-        let tracker = UserIpTracker::new();
-
-        let users = users_from_config(&cfg, &stats, &tracker, None, None, None).await;
-        let alice = users
-            .iter()
-            .find(|entry| entry.username == "alice")
-            .expect("alice must be present");
-        assert!(!alice.in_runtime);
-        assert_eq!(alice.max_tcp_conns, Some(7));
-
-        cfg.access.user_max_tcp_conns.insert("alice".to_string(), 5);
-        let users = users_from_config(&cfg, &stats, &tracker, None, None, None).await;
-        let alice = users
-            .iter()
-            .find(|entry| entry.username == "alice")
-            .expect("alice must be present");
-        assert!(!alice.in_runtime);
-        assert_eq!(alice.max_tcp_conns, Some(5));
-
-        cfg.access.user_max_tcp_conns.insert("alice".to_string(), 0);
-        let users = users_from_config(&cfg, &stats, &tracker, None, None, None).await;
-        let alice = users
-            .iter()
-            .find(|entry| entry.username == "alice")
-            .expect("alice must be present");
-        assert!(!alice.in_runtime);
-        assert_eq!(alice.max_tcp_conns, Some(7));
-
-        cfg.access.user_max_tcp_conns_global_each = 0;
-        let users = users_from_config(&cfg, &stats, &tracker, None, None, None).await;
-        let alice = users
-            .iter()
-            .find(|entry| entry.username == "alice")
-            .expect("alice must be present");
-        assert!(!alice.in_runtime);
-        assert_eq!(alice.max_tcp_conns, None);
-    }
-
-    #[tokio::test]
-    async fn users_from_config_marks_runtime_membership_when_snapshot_is_provided() {
-        let mut disk_cfg = ProxyConfig::default();
-        disk_cfg.access.users.insert(
-            "alice".to_string(),
-            "0123456789abcdef0123456789abcdef".to_string(),
-        );
-        disk_cfg.access.users.insert(
-            "bob".to_string(),
-            "fedcba9876543210fedcba9876543210".to_string(),
-        );
-
-        let mut runtime_cfg = ProxyConfig::default();
-        runtime_cfg.access.users.insert(
-            "alice".to_string(),
-            "0123456789abcdef0123456789abcdef".to_string(),
-        );
-
-        let stats = Stats::new();
-        let tracker = UserIpTracker::new();
-        let users =
-            users_from_config(&disk_cfg, &stats, &tracker, None, None, Some(&runtime_cfg)).await;
-
-        let alice = users
-            .iter()
-            .find(|entry| entry.username == "alice")
-            .expect("alice must be present");
-        let bob = users
-            .iter()
-            .find(|entry| entry.username == "bob")
-            .expect("bob must be present");
-
-        assert!(alice.in_runtime);
-        assert!(!bob.in_runtime);
-    }
-}

src/cli.rs

@@ -1,270 +1,11 @@
-//! CLI commands: --init (fire-and-forget setup), daemon options, subcommands
-//!
-//! Subcommands:
-//! - `start [OPTIONS] [config.toml]` - Start the daemon
-//! - `stop [--pid-file PATH]` - Stop a running daemon
-//! - `reload [--pid-file PATH]` - Reload configuration (SIGHUP)
-//! - `status [--pid-file PATH]` - Check daemon status
-//! - `run [OPTIONS] [config.toml]` - Run in foreground (default behavior)
+//! CLI commands: --init (fire-and-forget setup)
 
-use rand::RngExt;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-
-#[cfg(unix)]
-use crate::daemon::{self, DEFAULT_PID_FILE, DaemonOptions};
-
-/// CLI subcommand to execute.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Subcommand {
-    /// Run the proxy (default, or explicit `run` subcommand).
-    Run,
-    /// Start as daemon (`start` subcommand).
-    Start,
-    /// Stop a running daemon (`stop` subcommand).
-    Stop,
-    /// Reload configuration (`reload` subcommand).
-    Reload,
-    /// Check daemon status (`status` subcommand).
-    Status,
-    /// Fire-and-forget setup (`--init`).
-    Init,
-}
-
-/// Parsed subcommand with its options.
-#[derive(Debug)]
-pub struct ParsedCommand {
-    pub subcommand: Subcommand,
-    pub pid_file: PathBuf,
-    pub config_path: String,
-    #[cfg(unix)]
-    pub daemon_opts: DaemonOptions,
-    pub init_opts: Option<InitOptions>,
-}
-
-impl Default for ParsedCommand {
-    fn default() -> Self {
-        Self {
-            subcommand: Subcommand::Run,
-            #[cfg(unix)]
-            pid_file: PathBuf::from(DEFAULT_PID_FILE),
-            #[cfg(not(unix))]
-            pid_file: PathBuf::from("/var/run/telemt.pid"),
-            config_path: "config.toml".to_string(),
-            #[cfg(unix)]
-            daemon_opts: DaemonOptions::default(),
-            init_opts: None,
-        }
-    }
-}
-
-/// Parse CLI arguments into a command structure.
-pub fn parse_command(args: &[String]) -> ParsedCommand {
-    let mut cmd = ParsedCommand::default();
-
-    // Check for --init first (legacy form)
-    if args.iter().any(|a| a == "--init") {
-        cmd.subcommand = Subcommand::Init;
-        cmd.init_opts = parse_init_args(args);
-        return cmd;
-    }
-
-    // Check for subcommand as first argument
-    if let Some(first) = args.first() {
-        match first.as_str() {
-            "start" => {
-                cmd.subcommand = Subcommand::Start;
-                #[cfg(unix)]
-                {
-                    cmd.daemon_opts = parse_daemon_args(args);
-                    // Force daemonize for start command
-                    cmd.daemon_opts.daemonize = true;
-                }
-            }
-            "stop" => {
-                cmd.subcommand = Subcommand::Stop;
-            }
-            "reload" => {
-                cmd.subcommand = Subcommand::Reload;
-            }
-            "status" => {
-                cmd.subcommand = Subcommand::Status;
-            }
-            "run" => {
-                cmd.subcommand = Subcommand::Run;
-                #[cfg(unix)]
-                {
-                    cmd.daemon_opts = parse_daemon_args(args);
-                }
-            }
-            _ => {
-                // No subcommand, default to Run
-                #[cfg(unix)]
-                {
-                    cmd.daemon_opts = parse_daemon_args(args);
-                }
-            }
-        }
-    }
-
-    // Parse remaining options
-    let mut i = 0;
-    while i < args.len() {
-        match args[i].as_str() {
-            // Skip subcommand names
-            "start" | "stop" | "reload" | "status" | "run" => {}
-            // PID file option (for stop/reload/status)
-            "--pid-file" => {
-                i += 1;
-                if i < args.len() {
-                    cmd.pid_file = PathBuf::from(&args[i]);
-                    #[cfg(unix)]
-                    {
-                        cmd.daemon_opts.pid_file = Some(cmd.pid_file.clone());
-                    }
-                }
-            }
-            s if s.starts_with("--pid-file=") => {
-                cmd.pid_file = PathBuf::from(s.trim_start_matches("--pid-file="));
-                #[cfg(unix)]
-                {
-                    cmd.daemon_opts.pid_file = Some(cmd.pid_file.clone());
-                }
-            }
-            // Config path (positional, non-flag argument)
-            s if !s.starts_with('-') => {
-                cmd.config_path = s.to_string();
-            }
-            _ => {}
-        }
-        i += 1;
-    }
-
-    cmd
-}
-
-/// Execute a subcommand that doesn't require starting the server.
-/// Returns `Some(exit_code)` if the command was handled, `None` if server should start.
-#[cfg(unix)]
-pub fn execute_subcommand(cmd: &ParsedCommand) -> Option<i32> {
-    match cmd.subcommand {
-        Subcommand::Stop => Some(cmd_stop(&cmd.pid_file)),
-        Subcommand::Reload => Some(cmd_reload(&cmd.pid_file)),
-        Subcommand::Status => Some(cmd_status(&cmd.pid_file)),
-        Subcommand::Init => {
-            if let Some(opts) = cmd.init_opts.clone() {
-                match run_init(opts) {
-                    Ok(()) => Some(0),
-                    Err(e) => {
-                        eprintln!("[telemt] Init failed: {}", e);
-                        Some(1)
-                    }
-                }
-            } else {
-                Some(1)
-            }
-        }
-        // Run and Start need the server
-        Subcommand::Run | Subcommand::Start => None,
-    }
-}
-
-#[cfg(not(unix))]
-pub fn execute_subcommand(cmd: &ParsedCommand) -> Option<i32> {
-    match cmd.subcommand {
-        Subcommand::Stop | Subcommand::Reload | Subcommand::Status => {
-            eprintln!("[telemt] Subcommand not supported on this platform");
-            Some(1)
-        }
-        Subcommand::Init => {
-            if let Some(opts) = cmd.init_opts.clone() {
-                match run_init(opts) {
-                    Ok(()) => Some(0),
-                    Err(e) => {
-                        eprintln!("[telemt] Init failed: {}", e);
-                        Some(1)
-                    }
-                }
-            } else {
-                Some(1)
-            }
-        }
-        Subcommand::Run | Subcommand::Start => None,
-    }
-}
-
-/// Stop command: send SIGTERM to the running daemon.
-#[cfg(unix)]
-fn cmd_stop(pid_file: &Path) -> i32 {
-    use nix::sys::signal::Signal;
-
-    println!("Stopping telemt daemon...");
-
-    match daemon::signal_pid_file(pid_file, Signal::SIGTERM) {
-        Ok(()) => {
-            println!("Stop signal sent successfully");
-
-            // Wait for process to exit (up to 10 seconds)
-            for _ in 0..20 {
-                std::thread::sleep(std::time::Duration::from_millis(500));
-                if let daemon::DaemonStatus::NotRunning = daemon::check_status(pid_file) {
-                    println!("Daemon stopped");
-                    return 0;
-                }
-            }
-            println!("Daemon may still be shutting down");
-            0
-        }
-        Err(e) => {
-            eprintln!("Failed to stop daemon: {}", e);
-            1
-        }
-    }
-}
-
-/// Reload command: send SIGHUP to trigger config reload.
-#[cfg(unix)]
-fn cmd_reload(pid_file: &Path) -> i32 {
-    use nix::sys::signal::Signal;
-
-    println!("Reloading telemt configuration...");
-
-    match daemon::signal_pid_file(pid_file, Signal::SIGHUP) {
-        Ok(()) => {
-            println!("Reload signal sent successfully");
-            0
-        }
-        Err(e) => {
-            eprintln!("Failed to reload daemon: {}", e);
-            1
-        }
-    }
-}
-
-/// Status command: check if daemon is running.
-#[cfg(unix)]
-fn cmd_status(pid_file: &Path) -> i32 {
-    match daemon::check_status(pid_file) {
-        daemon::DaemonStatus::Running(pid) => {
-            println!("telemt is running (pid {})", pid);
-            0
-        }
-        daemon::DaemonStatus::Stale(pid) => {
-            println!("telemt is not running (stale pid file, was pid {})", pid);
-            // Clean up stale PID file
-            let _ = std::fs::remove_file(pid_file);
-            1
-        }
-        daemon::DaemonStatus::NotRunning => {
-            println!("telemt is not running");
-            1
-        }
-    }
-}
+use rand::Rng;
 
 /// Options for the init command
-#[derive(Debug, Clone)]
 pub struct InitOptions {
     pub port: u16,
     pub domain: String,
@@ -274,64 +15,6 @@ pub struct InitOptions {
     pub no_start: bool,
 }
 
-/// Parse daemon-related options from CLI args.
-#[cfg(unix)]
-pub fn parse_daemon_args(args: &[String]) -> DaemonOptions {
-    let mut opts = DaemonOptions::default();
-    let mut i = 0;
-
-    while i < args.len() {
-        match args[i].as_str() {
-            "--daemon" | "-d" => {
-                opts.daemonize = true;
-            }
-            "--foreground" | "-f" => {
-                opts.foreground = true;
-            }
-            "--pid-file" => {
-                i += 1;
-                if i < args.len() {
-                    opts.pid_file = Some(PathBuf::from(&args[i]));
-                }
-            }
-            s if s.starts_with("--pid-file=") => {
-                opts.pid_file = Some(PathBuf::from(s.trim_start_matches("--pid-file=")));
-            }
-            "--run-as-user" => {
-                i += 1;
-                if i < args.len() {
-                    opts.user = Some(args[i].clone());
-                }
-            }
-            s if s.starts_with("--run-as-user=") => {
-                opts.user = Some(s.trim_start_matches("--run-as-user=").to_string());
-            }
-            "--run-as-group" => {
-                i += 1;
-                if i < args.len() {
-                    opts.group = Some(args[i].clone());
-                }
-            }
-            s if s.starts_with("--run-as-group=") => {
-                opts.group = Some(s.trim_start_matches("--run-as-group=").to_string());
-            }
-            "--working-dir" => {
-                i += 1;
-                if i < args.len() {
-                    opts.working_dir = Some(PathBuf::from(&args[i]));
-                }
-            }
-            s if s.starts_with("--working-dir=") => {
-                opts.working_dir = Some(PathBuf::from(s.trim_start_matches("--working-dir=")));
-            }
-            _ => {}
-        }
-        i += 1;
-    }
-
-    opts
-}
-
 impl Default for InitOptions {
     fn default() -> Self {
         Self {
@@ -401,16 +84,10 @@ pub fn parse_init_args(args: &[String]) -> Option<InitOptions> {
 
 /// Run the fire-and-forget setup.
 pub fn run_init(opts: InitOptions) -> Result<(), Box<dyn std::error::Error>> {
-    use crate::service::{self, InitSystem, ServiceOptions};
-
     eprintln!("[telemt] Fire-and-forget setup");
     eprintln!();
     
-    // 1. Detect init system
-    let init_system = service::detect_init_system();
-    eprintln!("[+] Detected init system: {}", init_system);
-
-    // 2. Generate or validate secret
+    // 1. Generate or validate secret
     let secret = match opts.secret {
         Some(s) => {
             if s.len() != 32 || !s.chars().all(|c| c.is_ascii_hexdigit()) {
@@ -427,74 +104,50 @@ pub fn run_init(opts: InitOptions) -> Result<(), Box<dyn std::error::Error>> {
     eprintln!("[+] Port:   {}", opts.port);
     eprintln!("[+] Domain: {}", opts.domain);
     
-    // 3. Create config directory
+    // 2. Create config directory
     fs::create_dir_all(&opts.config_dir)?;
     let config_path = opts.config_dir.join("config.toml");
     
-    // 4. Write config
+    // 3. Write config
     let config_content = generate_config(&opts.username, &secret, opts.port, &opts.domain);
     fs::write(&config_path, &config_content)?;
     eprintln!("[+] Config written to {}", config_path.display());
     
-    // 5. Generate and write service file
-    let exe_path =
-        std::env::current_exe().unwrap_or_else(|_| PathBuf::from("/usr/local/bin/telemt"));
+    // 4. Write systemd unit
+    let exe_path = std::env::current_exe()
+        .unwrap_or_else(|_| PathBuf::from("/usr/local/bin/telemt"));
     
-    let service_opts = ServiceOptions {
-        exe_path: &exe_path,
-        config_path: &config_path,
-        user: None, // Let systemd/init handle user
-        group: None,
-        pid_file: "/var/run/telemt.pid",
-        working_dir: Some("/var/lib/telemt"),
-        description: "Telemt MTProxy - Telegram MTProto Proxy",
-    };
+    let unit_path = Path::new("/etc/systemd/system/telemt.service");
+    let unit_content = generate_systemd_unit(&exe_path, &config_path);
     
-    let service_path = service::service_file_path(init_system);
-    let service_content = service::generate_service_file(init_system, &service_opts);
-
-    // Ensure parent directory exists
-    if let Some(parent) = Path::new(service_path).parent() {
-        let _ = fs::create_dir_all(parent);
-    }
-
-    match fs::write(service_path, &service_content) {
+    match fs::write(unit_path, &unit_content) {
         Ok(()) => {
-            eprintln!("[+] Service file written to {}", service_path);
-
-            // Make script executable for OpenRC/FreeBSD
-            #[cfg(unix)]
-            if init_system == InitSystem::OpenRC || init_system == InitSystem::FreeBSDRc {
-                use std::os::unix::fs::PermissionsExt;
-                let mut perms = fs::metadata(service_path)?.permissions();
-                perms.set_mode(0o755);
-                fs::set_permissions(service_path, perms)?;
-            }
+            eprintln!("[+] Systemd unit written to {}", unit_path.display());
         }
         Err(e) => {
-            eprintln!("[!] Cannot write service file (run as root?): {}", e);
-            eprintln!("[!] Manual service file content:");
-            eprintln!("{}", service_content);
+            eprintln!("[!] Cannot write systemd unit (run as root?): {}", e);
+            eprintln!("[!] Manual unit file content:");
+            eprintln!("{}", unit_content);
             
-            // Still print links and installation instructions
-            eprintln!();
-            eprintln!("{}", service::installation_instructions(init_system));
+            // Still print links and config
             print_links(&opts.username, &secret, opts.port, &opts.domain);
             return Ok(());
         }
     }
     
-    // 6. Install and enable service based on init system
-    match init_system {
-        InitSystem::Systemd => {
+    // 5. Reload systemd
     run_cmd("systemctl", &["daemon-reload"]);
+    
+    // 6. Enable service
     run_cmd("systemctl", &["enable", "telemt.service"]);
     eprintln!("[+] Service enabled");
     
+    // 7. Start service (unless --no-start)
     if !opts.no_start {
         run_cmd("systemctl", &["start", "telemt.service"]);
         eprintln!("[+] Service started");
         
+        // Brief delay then check status
         std::thread::sleep(std::time::Duration::from_secs(1));
         let status = Command::new("systemctl")
             .args(["is-active", "telemt.service"])
@@ -513,40 +166,10 @@ pub fn run_init(opts: InitOptions) -> Result<(), Box<dyn std::error::Error>> {
         eprintln!("[+] Service not started (--no-start)");
         eprintln!("[+] Start manually: systemctl start telemt.service");
     }
-        }
-        InitSystem::OpenRC => {
-            run_cmd("rc-update", &["add", "telemt", "default"]);
-            eprintln!("[+] Service enabled");
-
-            if !opts.no_start {
-                run_cmd("rc-service", &["telemt", "start"]);
-                eprintln!("[+] Service started");
-            } else {
-                eprintln!("[+] Service not started (--no-start)");
-                eprintln!("[+] Start manually: rc-service telemt start");
-            }
-        }
-        InitSystem::FreeBSDRc => {
-            run_cmd("sysrc", &["telemt_enable=YES"]);
-            eprintln!("[+] Service enabled");
-
-            if !opts.no_start {
-                run_cmd("service", &["telemt", "start"]);
-                eprintln!("[+] Service started");
-            } else {
-                eprintln!("[+] Service not started (--no-start)");
-                eprintln!("[+] Start manually: service telemt start");
-            }
-        }
-        InitSystem::Unknown => {
-            eprintln!("[!] Unknown init system - service file written but not installed");
-            eprintln!("[!] You may need to install it manually");
-        }
-    }
     
     eprintln!();
     
-    // 7. Print links
+    // 8. Print links
     print_links(&opts.username, &secret, opts.port, &opts.domain);
     
     Ok(())
@@ -560,7 +183,7 @@ fn generate_secret() -> String {
 
 fn generate_config(username: &str, secret: &str, port: u16, domain: &str) -> String {
     format!(
-        r#"# Telemt MTProxy — auto-generated config
+r#"# Telemt MTProxy — auto-generated config
 # Re-run `telemt --init` to regenerate
 
 show_link = ["{username}"]
@@ -575,16 +198,8 @@ desync_all_full = false
 update_every = 43200
 hardswap = false
 me_pool_drain_ttl_secs = 90
-me_instadrain = false
-me_pool_drain_threshold = 32
-me_pool_drain_soft_evict_grace_secs = 10
-me_pool_drain_soft_evict_per_writer = 2
-me_pool_drain_soft_evict_budget_per_core = 16
-me_pool_drain_soft_evict_cooldown_ms = 1000
-me_bind_stale_mode = "never"
 me_pool_min_fresh_ratio = 0.8
-me_reinit_drain_timeout_secs = 90
-tg_connect = 10
+me_reinit_drain_timeout_secs = 120
 
 [network]
 ipv4 = true
@@ -610,8 +225,8 @@ ip = "0.0.0.0"
 ip = "::"
 
 [timeouts]
-client_first_byte_idle_secs = 300
-client_handshake = 60
+client_handshake = 15
+tg_connect = 10
 client_keepalive = 60
 client_ack = 300
 
@@ -623,9 +238,8 @@ fake_cert_len = 2048
 tls_full_cert_ttl_secs = 90
 
 [access]
-user_max_tcp_conns_global_each = 0
 replay_check_len = 65536
-replay_window_secs = 120
+replay_window_secs = 1800
 ignore_time_skew = false
 
 [access.users]
@@ -643,6 +257,35 @@ weight = 10
     )
 }
 
+fn generate_systemd_unit(exe_path: &Path, config_path: &Path) -> String {
+    format!(
+r#"[Unit]
+Description=Telemt MTProxy
+Documentation=https://github.com/nicepkg/telemt
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart={exe} {config}
+Restart=always
+RestartSec=5
+LimitNOFILE=65535
+# Security hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/etc/telemt
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
+"#,
+        exe = exe_path.display(),
+        config = config_path.display(),
+    )
+}
+
 fn run_cmd(cmd: &str, args: &[&str]) {
     match Command::new(cmd).args(args).output() {
         Ok(output) => {
@@ -662,10 +305,8 @@ fn print_links(username: &str, secret: &str, port: u16, domain: &str) {
     
     println!("=== Proxy Links ===");
     println!("[{}]", username);
-    println!(
-        "  EE-TLS:  tg://proxy?server=YOUR_SERVER_IP&port={}&secret=ee{}{}",
-        port, secret, domain_hex
-    );
+    println!("  EE-TLS:  tg://proxy?server=YOUR_SERVER_IP&port={}&secret=ee{}{}", 
+        port, secret, domain_hex);
     println!();
     println!("Replace YOUR_SERVER_IP with your server's public IP.");
     println!("The proxy will auto-detect and display the correct link on startup.");

src/config/defaults.rs

@@ -1,6 +1,6 @@
+use std::collections::HashMap;
 use ipnetwork::IpNetwork;
 use serde::Deserialize;
-use std::collections::HashMap;
 
 // Helper defaults kept private to the config module.
 const DEFAULT_NETWORK_IPV6: Option<bool> = Some(false);
@@ -27,10 +27,8 @@ const DEFAULT_ME_C2ME_CHANNEL_CAPACITY: usize = 1024;
 const DEFAULT_ME_READER_ROUTE_DATA_WAIT_MS: u64 = 2;
 const DEFAULT_ME_D2C_FLUSH_BATCH_MAX_FRAMES: usize = 32;
 const DEFAULT_ME_D2C_FLUSH_BATCH_MAX_BYTES: usize = 128 * 1024;
-const DEFAULT_ME_D2C_FLUSH_BATCH_MAX_DELAY_US: u64 = 500;
-const DEFAULT_ME_D2C_ACK_FLUSH_IMMEDIATE: bool = true;
-const DEFAULT_ME_QUOTA_SOFT_OVERSHOOT_BYTES: u64 = 64 * 1024;
-const DEFAULT_ME_D2C_FRAME_BUF_SHRINK_THRESHOLD_BYTES: usize = 256 * 1024;
+const DEFAULT_ME_D2C_FLUSH_BATCH_MAX_DELAY_US: u64 = 1500;
+const DEFAULT_ME_D2C_ACK_FLUSH_IMMEDIATE: bool = false;
 const DEFAULT_DIRECT_RELAY_COPY_BUF_C2S_BYTES: usize = 64 * 1024;
 const DEFAULT_DIRECT_RELAY_COPY_BUF_S2C_BYTES: usize = 256 * 1024;
 const DEFAULT_ME_WRITER_PICK_SAMPLE_SIZE: u8 = 3;
@@ -38,20 +36,7 @@ const DEFAULT_ME_HEALTH_INTERVAL_MS_UNHEALTHY: u64 = 1000;
 const DEFAULT_ME_HEALTH_INTERVAL_MS_HEALTHY: u64 = 3000;
 const DEFAULT_ME_ADMISSION_POLL_MS: u64 = 1000;
 const DEFAULT_ME_WARN_RATE_LIMIT_MS: u64 = 5000;
-const DEFAULT_ME_ROUTE_HYBRID_MAX_WAIT_MS: u64 = 3000;
-const DEFAULT_ME_ROUTE_BLOCKING_SEND_TIMEOUT_MS: u64 = 250;
-const DEFAULT_ME_C2ME_SEND_TIMEOUT_MS: u64 = 4000;
-const DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_ENABLED: bool = true;
-const DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_GRACE_SECS: u64 = 10;
-const DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_PER_WRITER: u8 = 2;
-const DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_BUDGET_PER_CORE: u16 = 16;
-const DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_COOLDOWN_MS: u64 = 1000;
 const DEFAULT_USER_MAX_UNIQUE_IPS_WINDOW_SECS: u64 = 30;
-const DEFAULT_ACCEPT_PERMIT_TIMEOUT_MS: u64 = 250;
-const DEFAULT_CONNTRACK_CONTROL_ENABLED: bool = true;
-const DEFAULT_CONNTRACK_PRESSURE_HIGH_WATERMARK_PCT: u8 = 85;
-const DEFAULT_CONNTRACK_PRESSURE_LOW_WATERMARK_PCT: u8 = 70;
-const DEFAULT_CONNTRACK_DELETE_BUDGET_PER_SEC: u64 = 4096;
 const DEFAULT_UPSTREAM_CONNECT_RETRY_ATTEMPTS: u32 = 2;
 const DEFAULT_UPSTREAM_UNHEALTHY_FAIL_THRESHOLD: u32 = 5;
 const DEFAULT_UPSTREAM_CONNECT_BUDGET_MS: u64 = 3000;
@@ -71,26 +56,6 @@ pub(crate) fn default_tls_domain() -> String {
     "petrovich.ru".to_string()
 }
 
-pub(crate) fn default_tls_fetch_scope() -> String {
-    String::new()
-}
-
-pub(crate) fn default_tls_fetch_attempt_timeout_ms() -> u64 {
-    5_000
-}
-
-pub(crate) fn default_tls_fetch_total_budget_ms() -> u64 {
-    15_000
-}
-
-pub(crate) fn default_tls_fetch_strict_route() -> bool {
-    true
-}
-
-pub(crate) fn default_tls_fetch_profile_cache_ttl_secs() -> u64 {
-    600
-}
-
 pub(crate) fn default_mask_port() -> u16 {
     443
 }
@@ -100,7 +65,7 @@ pub(crate) fn default_fake_cert_len() -> usize {
 }
 
 pub(crate) fn default_tls_front_dir() -> String {
-    "/etc/telemt/tlsfront".to_string()
+    "tlsfront".to_string()
 }
 
 pub(crate) fn default_replay_check_len() -> usize {
@@ -108,32 +73,10 @@ pub(crate) fn default_replay_check_len() -> usize {
 }
 
 pub(crate) fn default_replay_window_secs() -> u64 {
-    // Keep replay cache TTL tight by default to reduce replay surface.
-    // Deployments with higher RTT or longer reconnect jitter can override this in config.
-    120
+    1800
 }
 
 pub(crate) fn default_handshake_timeout() -> u64 {
-    60
-}
-
-pub(crate) fn default_client_first_byte_idle_secs() -> u64 {
-    300
-}
-
-pub(crate) fn default_relay_idle_policy_v2_enabled() -> bool {
-    true
-}
-
-pub(crate) fn default_relay_client_idle_soft_secs() -> u64 {
-    120
-}
-
-pub(crate) fn default_relay_client_idle_hard_secs() -> u64 {
-    360
-}
-
-pub(crate) fn default_relay_idle_grace_after_downstream_activity_secs() -> u64 {
     30
 }
 
@@ -142,11 +85,11 @@ pub(crate) fn default_connect_timeout() -> u64 {
 }
 
 pub(crate) fn default_keepalive() -> u64 {
-    15
+    60
 }
 
 pub(crate) fn default_ack_timeout() -> u64 {
-    90
+    300
 }
 pub(crate) fn default_me_one_retry() -> u8 {
     12
@@ -169,15 +112,18 @@ pub(crate) fn default_weight() -> u16 {
 }
 
 pub(crate) fn default_metrics_whitelist() -> Vec<IpNetwork> {
-    vec!["127.0.0.1/32".parse().unwrap(), "::1/128".parse().unwrap()]
+    vec![
+        "127.0.0.1/32".parse().unwrap(),
+        "::1/128".parse().unwrap(),
+    ]
 }
 
 pub(crate) fn default_api_listen() -> String {
-    "0.0.0.0:9091".to_string()
+    "127.0.0.1:9091".to_string()
 }
 
 pub(crate) fn default_api_whitelist() -> Vec<IpNetwork> {
-    vec!["127.0.0.0/8".parse().unwrap()]
+    default_metrics_whitelist()
 }
 
 pub(crate) fn default_api_request_body_limit_bytes() -> usize {
@@ -185,62 +131,22 @@ pub(crate) fn default_api_request_body_limit_bytes() -> usize {
 }
 
 pub(crate) fn default_api_minimal_runtime_enabled() -> bool {
-    true
+    false
 }
 
 pub(crate) fn default_api_minimal_runtime_cache_ttl_ms() -> u64 {
     1000
 }
 
-pub(crate) fn default_api_runtime_edge_enabled() -> bool {
-    false
-}
-pub(crate) fn default_api_runtime_edge_cache_ttl_ms() -> u64 {
-    1000
-}
-pub(crate) fn default_api_runtime_edge_top_n() -> usize {
-    10
-}
-pub(crate) fn default_api_runtime_edge_events_capacity() -> usize {
-    256
-}
+pub(crate) fn default_api_runtime_edge_enabled() -> bool { false }
+pub(crate) fn default_api_runtime_edge_cache_ttl_ms() -> u64 { 1000 }
+pub(crate) fn default_api_runtime_edge_top_n() -> usize { 10 }
+pub(crate) fn default_api_runtime_edge_events_capacity() -> usize { 256 }
 
 pub(crate) fn default_proxy_protocol_header_timeout_ms() -> u64 {
     500
 }
 
-pub(crate) fn default_proxy_protocol_trusted_cidrs() -> Vec<IpNetwork> {
-    vec!["0.0.0.0/0".parse().unwrap(), "::/0".parse().unwrap()]
-}
-
-pub(crate) fn default_server_max_connections() -> u32 {
-    10_000
-}
-
-pub(crate) fn default_listen_backlog() -> u32 {
-    1024
-}
-
-pub(crate) fn default_accept_permit_timeout_ms() -> u64 {
-    DEFAULT_ACCEPT_PERMIT_TIMEOUT_MS
-}
-
-pub(crate) fn default_conntrack_control_enabled() -> bool {
-    DEFAULT_CONNTRACK_CONTROL_ENABLED
-}
-
-pub(crate) fn default_conntrack_pressure_high_watermark_pct() -> u8 {
-    DEFAULT_CONNTRACK_PRESSURE_HIGH_WATERMARK_PCT
-}
-
-pub(crate) fn default_conntrack_pressure_low_watermark_pct() -> u8 {
-    DEFAULT_CONNTRACK_PRESSURE_LOW_WATERMARK_PCT
-}
-
-pub(crate) fn default_conntrack_delete_budget_per_sec() -> u64 {
-    DEFAULT_CONNTRACK_DELETE_BUDGET_PER_SEC
-}
-
 pub(crate) fn default_prefer_4() -> u8 {
     4
 }
@@ -301,10 +207,6 @@ pub(crate) fn default_me2dc_fallback() -> bool {
     true
 }
 
-pub(crate) fn default_me2dc_fast() -> bool {
-    true
-}
-
 pub(crate) fn default_keepalive_interval() -> u64 {
     8
 }
@@ -441,14 +343,6 @@ pub(crate) fn default_me_d2c_ack_flush_immediate() -> bool {
     DEFAULT_ME_D2C_ACK_FLUSH_IMMEDIATE
 }
 
-pub(crate) fn default_me_quota_soft_overshoot_bytes() -> u64 {
-    DEFAULT_ME_QUOTA_SOFT_OVERSHOOT_BYTES
-}
-
-pub(crate) fn default_me_d2c_frame_buf_shrink_threshold_bytes() -> usize {
-    DEFAULT_ME_D2C_FRAME_BUF_SHRINK_THRESHOLD_BYTES
-}
-
 pub(crate) fn default_direct_relay_copy_buf_c2s_bytes() -> usize {
     DEFAULT_DIRECT_RELAY_COPY_BUF_C2S_BYTES
 }
@@ -477,18 +371,6 @@ pub(crate) fn default_me_warn_rate_limit_ms() -> u64 {
     DEFAULT_ME_WARN_RATE_LIMIT_MS
 }
 
-pub(crate) fn default_me_route_hybrid_max_wait_ms() -> u64 {
-    DEFAULT_ME_ROUTE_HYBRID_MAX_WAIT_MS
-}
-
-pub(crate) fn default_me_route_blocking_send_timeout_ms() -> u64 {
-    DEFAULT_ME_ROUTE_BLOCKING_SEND_TIMEOUT_MS
-}
-
-pub(crate) fn default_me_c2me_send_timeout_ms() -> u64 {
-    DEFAULT_ME_C2ME_SEND_TIMEOUT_MS
-}
-
 pub(crate) fn default_upstream_connect_retry_attempts() -> u32 {
     DEFAULT_UPSTREAM_CONNECT_RETRY_ATTEMPTS
 }
@@ -558,7 +440,7 @@ pub(crate) fn default_beobachten_flush_secs() -> u64 {
 }
 
 pub(crate) fn default_beobachten_file() -> String {
-    "/etc/telemt/beobachten.txt".to_string()
+    "cache/beobachten.txt".to_string()
 }
 
 pub(crate) fn default_tls_new_session_tickets() -> u8 {
@@ -570,67 +452,17 @@ pub(crate) fn default_tls_full_cert_ttl_secs() -> u64 {
 }
 
 pub(crate) fn default_server_hello_delay_min_ms() -> u64 {
-    8
+    0
 }
 
 pub(crate) fn default_server_hello_delay_max_ms() -> u64 {
-    24
+    0
 }
 
 pub(crate) fn default_alpn_enforce() -> bool {
     true
 }
 
-pub(crate) fn default_mask_shape_hardening() -> bool {
-    true
-}
-
-pub(crate) fn default_mask_shape_hardening_aggressive_mode() -> bool {
-    false
-}
-
-pub(crate) fn default_mask_shape_bucket_floor_bytes() -> usize {
-    512
-}
-
-pub(crate) fn default_mask_shape_bucket_cap_bytes() -> usize {
-    4096
-}
-
-pub(crate) fn default_mask_shape_above_cap_blur() -> bool {
-    false
-}
-
-pub(crate) fn default_mask_shape_above_cap_blur_max_bytes() -> usize {
-    512
-}
-
-#[cfg(not(test))]
-pub(crate) fn default_mask_relay_max_bytes() -> usize {
-    5 * 1024 * 1024
-}
-
-#[cfg(test)]
-pub(crate) fn default_mask_relay_max_bytes() -> usize {
-    32 * 1024
-}
-
-pub(crate) fn default_mask_classifier_prefetch_timeout_ms() -> u64 {
-    5
-}
-
-pub(crate) fn default_mask_timing_normalization_enabled() -> bool {
-    false
-}
-
-pub(crate) fn default_mask_timing_normalization_floor_ms() -> u64 {
-    0
-}
-
-pub(crate) fn default_mask_timing_normalization_ceiling_ms() -> u64 {
-    0
-}
-
 pub(crate) fn default_stun_servers() -> Vec<String> {
     vec![
         "stun.l.google.com:5349".to_string(),
@@ -745,41 +577,13 @@ pub(crate) fn default_proxy_secret_len_max() -> usize {
 }
 
 pub(crate) fn default_me_reinit_drain_timeout_secs() -> u64 {
-    90
+    120
 }
 
 pub(crate) fn default_me_pool_drain_ttl_secs() -> u64 {
     90
 }
 
-pub(crate) fn default_me_instadrain() -> bool {
-    false
-}
-
-pub(crate) fn default_me_pool_drain_threshold() -> u64 {
-    32
-}
-
-pub(crate) fn default_me_pool_drain_soft_evict_enabled() -> bool {
-    DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_ENABLED
-}
-
-pub(crate) fn default_me_pool_drain_soft_evict_grace_secs() -> u64 {
-    DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_GRACE_SECS
-}
-
-pub(crate) fn default_me_pool_drain_soft_evict_per_writer() -> u8 {
-    DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_PER_WRITER
-}
-
-pub(crate) fn default_me_pool_drain_soft_evict_budget_per_core() -> u16 {
-    DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_BUDGET_PER_CORE
-}
-
-pub(crate) fn default_me_pool_drain_soft_evict_cooldown_ms() -> u64 {
-    DEFAULT_ME_POOL_DRAIN_SOFT_EVICT_COOLDOWN_MS
-}
-
 pub(crate) fn default_me_bind_stale_ttl_secs() -> u64 {
     default_me_pool_drain_ttl_secs()
 }
@@ -831,14 +635,6 @@ pub(crate) fn default_user_max_unique_ips_window_secs() -> u64 {
     DEFAULT_USER_MAX_UNIQUE_IPS_WINDOW_SECS
 }
 
-pub(crate) fn default_user_max_tcp_conns_global_each() -> usize {
-    0
-}
-
-pub(crate) fn default_user_max_unique_ips_global_each() -> usize {
-    0
-}
-
 // Custom deserializer helpers
 
 #[derive(Deserialize)]

src/config/hot_reload.rs

@@ -21,22 +21,19 @@
 //! `network.*`, `use_middle_proxy`) are **not** applied; a warning is emitted.
 //! Non-hot changes are never mixed into the runtime config snapshot.
 
-use std::collections::BTreeSet;
 use std::net::IpAddr;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, RwLock as StdRwLock};
-use std::time::Duration;
+use std::path::PathBuf;
+use std::sync::Arc;
 
 use notify::{EventKind, RecursiveMode, Watcher, recommended_watcher};
 use tokio::sync::{mpsc, watch};
 use tracing::{error, info, warn};
 
-use super::load::{LoadedConfig, ProxyConfig};
 use crate::config::{
-    LogLevel, MeBindStaleMode, MeFloorMode, MeSocksKdfPolicy, MeTelemetryLevel, MeWriterPickMode,
+    LogLevel, MeBindStaleMode, MeFloorMode, MeSocksKdfPolicy, MeTelemetryLevel,
+    MeWriterPickMode,
 };
-
-const HOT_RELOAD_DEBOUNCE: Duration = Duration::from_millis(50);
+use super::load::ProxyConfig;
 
 // ── Hot fields ────────────────────────────────────────────────────────────────
 
@@ -53,8 +50,6 @@ pub struct HotFields {
     pub me_reinit_coalesce_window_ms: u64,
     pub hardswap:                bool,
     pub me_pool_drain_ttl_secs:  u64,
-    pub me_instadrain: bool,
-    pub me_pool_drain_threshold: u64,
     pub me_pool_min_fresh_ratio: f32,
     pub me_reinit_drain_timeout_secs: u64,
     pub me_hardswap_warmup_delay_min_ms: u64,
@@ -106,8 +101,6 @@ pub struct HotFields {
     pub me_d2c_flush_batch_max_bytes: usize,
     pub me_d2c_flush_batch_max_delay_us: u64,
     pub me_d2c_ack_flush_immediate: bool,
-    pub me_quota_soft_overshoot_bytes: u64,
-    pub me_d2c_frame_buf_shrink_threshold_bytes: usize,
     pub direct_relay_copy_buf_c2s_bytes: usize,
     pub direct_relay_copy_buf_s2c_bytes: usize,
     pub me_health_interval_ms_unhealthy: u64,
@@ -117,11 +110,9 @@ pub struct HotFields {
     pub users:                   std::collections::HashMap<String, String>,
     pub user_ad_tags:            std::collections::HashMap<String, String>,
     pub user_max_tcp_conns:      std::collections::HashMap<String, usize>,
-    pub user_max_tcp_conns_global_each: usize,
     pub user_expirations:        std::collections::HashMap<String, chrono::DateTime<chrono::Utc>>,
     pub user_data_quota:         std::collections::HashMap<String, u64>,
     pub user_max_unique_ips:     std::collections::HashMap<String, usize>,
-    pub user_max_unique_ips_global_each: usize,
     pub user_max_unique_ips_mode: crate::config::UserMaxUniqueIpsMode,
     pub user_max_unique_ips_window_secs: u64,
 }
@@ -139,8 +130,6 @@ impl HotFields {
             me_reinit_coalesce_window_ms: cfg.general.me_reinit_coalesce_window_ms,
             hardswap:                cfg.general.hardswap,
             me_pool_drain_ttl_secs:  cfg.general.me_pool_drain_ttl_secs,
-            me_instadrain: cfg.general.me_instadrain,
-            me_pool_drain_threshold: cfg.general.me_pool_drain_threshold,
             me_pool_min_fresh_ratio: cfg.general.me_pool_min_fresh_ratio,
             me_reinit_drain_timeout_secs: cfg.general.me_reinit_drain_timeout_secs,
             me_hardswap_warmup_delay_min_ms: cfg.general.me_hardswap_warmup_delay_min_ms,
@@ -191,11 +180,15 @@ impl HotFields {
             me_adaptive_floor_min_writers_multi_endpoint: cfg
                 .general
                 .me_adaptive_floor_min_writers_multi_endpoint,
-            me_adaptive_floor_recover_grace_secs: cfg.general.me_adaptive_floor_recover_grace_secs,
+            me_adaptive_floor_recover_grace_secs: cfg
+                .general
+                .me_adaptive_floor_recover_grace_secs,
             me_adaptive_floor_writers_per_core_total: cfg
                 .general
                 .me_adaptive_floor_writers_per_core_total,
-            me_adaptive_floor_cpu_cores_override: cfg.general.me_adaptive_floor_cpu_cores_override,
+            me_adaptive_floor_cpu_cores_override: cfg
+                .general
+                .me_adaptive_floor_cpu_cores_override,
             me_adaptive_floor_max_extra_writers_single_per_core: cfg
                 .general
                 .me_adaptive_floor_max_extra_writers_single_per_core,
@@ -214,24 +207,14 @@ impl HotFields {
             me_adaptive_floor_max_warm_writers_global: cfg
                 .general
                 .me_adaptive_floor_max_warm_writers_global,
-            me_route_backpressure_base_timeout_ms: cfg
-                .general
-                .me_route_backpressure_base_timeout_ms,
-            me_route_backpressure_high_timeout_ms: cfg
-                .general
-                .me_route_backpressure_high_timeout_ms,
-            me_route_backpressure_high_watermark_pct: cfg
-                .general
-                .me_route_backpressure_high_watermark_pct,
+            me_route_backpressure_base_timeout_ms: cfg.general.me_route_backpressure_base_timeout_ms,
+            me_route_backpressure_high_timeout_ms: cfg.general.me_route_backpressure_high_timeout_ms,
+            me_route_backpressure_high_watermark_pct: cfg.general.me_route_backpressure_high_watermark_pct,
             me_reader_route_data_wait_ms: cfg.general.me_reader_route_data_wait_ms,
             me_d2c_flush_batch_max_frames: cfg.general.me_d2c_flush_batch_max_frames,
             me_d2c_flush_batch_max_bytes: cfg.general.me_d2c_flush_batch_max_bytes,
             me_d2c_flush_batch_max_delay_us: cfg.general.me_d2c_flush_batch_max_delay_us,
             me_d2c_ack_flush_immediate: cfg.general.me_d2c_ack_flush_immediate,
-            me_quota_soft_overshoot_bytes: cfg.general.me_quota_soft_overshoot_bytes,
-            me_d2c_frame_buf_shrink_threshold_bytes: cfg
-                .general
-                .me_d2c_frame_buf_shrink_threshold_bytes,
             direct_relay_copy_buf_c2s_bytes: cfg.general.direct_relay_copy_buf_c2s_bytes,
             direct_relay_copy_buf_s2c_bytes: cfg.general.direct_relay_copy_buf_s2c_bytes,
             me_health_interval_ms_unhealthy: cfg.general.me_health_interval_ms_unhealthy,
@@ -241,11 +224,9 @@ impl HotFields {
             users:                   cfg.access.users.clone(),
             user_ad_tags:            cfg.access.user_ad_tags.clone(),
             user_max_tcp_conns:      cfg.access.user_max_tcp_conns.clone(),
-            user_max_tcp_conns_global_each: cfg.access.user_max_tcp_conns_global_each,
             user_expirations:        cfg.access.user_expirations.clone(),
             user_data_quota:         cfg.access.user_data_quota.clone(),
             user_max_unique_ips:     cfg.access.user_max_unique_ips.clone(),
-            user_max_unique_ips_global_each: cfg.access.user_max_unique_ips_global_each,
             user_max_unique_ips_mode: cfg.access.user_max_unique_ips_mode,
             user_max_unique_ips_window_secs: cfg.access.user_max_unique_ips_window_secs,
         }
@@ -306,129 +287,6 @@ fn listeners_equal(
     })
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-struct WatchManifest {
-    files: BTreeSet<PathBuf>,
-    dirs: BTreeSet<PathBuf>,
-}
-
-impl WatchManifest {
-    fn from_source_files(source_files: &[PathBuf]) -> Self {
-        let mut files = BTreeSet::new();
-        let mut dirs = BTreeSet::new();
-
-        for path in source_files {
-            let normalized = normalize_watch_path(path);
-            files.insert(normalized.clone());
-            if let Some(parent) = normalized.parent() {
-                dirs.insert(parent.to_path_buf());
-            }
-        }
-
-        Self { files, dirs }
-    }
-
-    fn matches_event_paths(&self, event_paths: &[PathBuf]) -> bool {
-        event_paths
-            .iter()
-            .map(|path| normalize_watch_path(path))
-            .any(|path| self.files.contains(&path))
-    }
-}
-
-#[derive(Debug, Default)]
-struct ReloadState {
-    applied_snapshot_hash: Option<u64>,
-}
-
-impl ReloadState {
-    fn new(applied_snapshot_hash: Option<u64>) -> Self {
-        Self {
-            applied_snapshot_hash,
-        }
-    }
-
-    fn is_applied(&self, hash: u64) -> bool {
-        self.applied_snapshot_hash == Some(hash)
-    }
-
-    fn mark_applied(&mut self, hash: u64) {
-        self.applied_snapshot_hash = Some(hash);
-    }
-}
-
-fn normalize_watch_path(path: &Path) -> PathBuf {
-    path.canonicalize().unwrap_or_else(|_| {
-        if path.is_absolute() {
-            path.to_path_buf()
-        } else {
-            std::env::current_dir()
-                .map(|cwd| cwd.join(path))
-                .unwrap_or_else(|_| path.to_path_buf())
-        }
-    })
-}
-
-fn sync_watch_paths<W: Watcher>(
-    watcher: &mut W,
-    current: &BTreeSet<PathBuf>,
-    next: &BTreeSet<PathBuf>,
-    recursive_mode: RecursiveMode,
-    kind: &str,
-) {
-    for path in current.difference(next) {
-        if let Err(e) = watcher.unwatch(path) {
-            warn!(path = %path.display(), error = %e, "config watcher: failed to unwatch {kind}");
-        }
-    }
-
-    for path in next.difference(current) {
-        if let Err(e) = watcher.watch(path, recursive_mode) {
-            warn!(path = %path.display(), error = %e, "config watcher: failed to watch {kind}");
-        }
-    }
-}
-
-fn apply_watch_manifest<W1: Watcher, W2: Watcher>(
-    notify_watcher: Option<&mut W1>,
-    poll_watcher: Option<&mut W2>,
-    manifest_state: &Arc<StdRwLock<WatchManifest>>,
-    next_manifest: WatchManifest,
-) {
-    let current_manifest = manifest_state
-        .read()
-        .map(|manifest| manifest.clone())
-        .unwrap_or_default();
-
-    if current_manifest == next_manifest {
-        return;
-    }
-
-    if let Some(watcher) = notify_watcher {
-        sync_watch_paths(
-            watcher,
-            &current_manifest.dirs,
-            &next_manifest.dirs,
-            RecursiveMode::NonRecursive,
-            "config directory",
-        );
-    }
-
-    if let Some(watcher) = poll_watcher {
-        sync_watch_paths(
-            watcher,
-            &current_manifest.files,
-            &next_manifest.files,
-            RecursiveMode::NonRecursive,
-            "config file",
-        );
-    }
-
-    if let Ok(mut manifest) = manifest_state.write() {
-        *manifest = next_manifest;
-    }
-}
-
 fn overlay_hot_fields(old: &ProxyConfig, new: &ProxyConfig) -> ProxyConfig {
     let mut cfg = old.clone();
 
@@ -444,8 +302,6 @@ fn overlay_hot_fields(old: &ProxyConfig, new: &ProxyConfig) -> ProxyConfig {
     cfg.general.me_reinit_coalesce_window_ms = new.general.me_reinit_coalesce_window_ms;
     cfg.general.hardswap = new.general.hardswap;
     cfg.general.me_pool_drain_ttl_secs = new.general.me_pool_drain_ttl_secs;
-    cfg.general.me_instadrain = new.general.me_instadrain;
-    cfg.general.me_pool_drain_threshold = new.general.me_pool_drain_threshold;
     cfg.general.me_pool_min_fresh_ratio = new.general.me_pool_min_fresh_ratio;
     cfg.general.me_reinit_drain_timeout_secs = new.general.me_reinit_drain_timeout_secs;
     cfg.general.me_hardswap_warmup_delay_min_ms = new.general.me_hardswap_warmup_delay_min_ms;
@@ -492,14 +348,10 @@ fn overlay_hot_fields(old: &ProxyConfig, new: &ProxyConfig) -> ProxyConfig {
         new.general.me_adaptive_floor_writers_per_core_total;
     cfg.general.me_adaptive_floor_cpu_cores_override =
         new.general.me_adaptive_floor_cpu_cores_override;
-    cfg.general
-        .me_adaptive_floor_max_extra_writers_single_per_core = new
-        .general
-        .me_adaptive_floor_max_extra_writers_single_per_core;
-    cfg.general
-        .me_adaptive_floor_max_extra_writers_multi_per_core = new
-        .general
-        .me_adaptive_floor_max_extra_writers_multi_per_core;
+    cfg.general.me_adaptive_floor_max_extra_writers_single_per_core =
+        new.general.me_adaptive_floor_max_extra_writers_single_per_core;
+    cfg.general.me_adaptive_floor_max_extra_writers_multi_per_core =
+        new.general.me_adaptive_floor_max_extra_writers_multi_per_core;
     cfg.general.me_adaptive_floor_max_active_writers_per_core =
         new.general.me_adaptive_floor_max_active_writers_per_core;
     cfg.general.me_adaptive_floor_max_warm_writers_per_core =
@@ -519,9 +371,6 @@ fn overlay_hot_fields(old: &ProxyConfig, new: &ProxyConfig) -> ProxyConfig {
     cfg.general.me_d2c_flush_batch_max_bytes = new.general.me_d2c_flush_batch_max_bytes;
     cfg.general.me_d2c_flush_batch_max_delay_us = new.general.me_d2c_flush_batch_max_delay_us;
     cfg.general.me_d2c_ack_flush_immediate = new.general.me_d2c_ack_flush_immediate;
-    cfg.general.me_quota_soft_overshoot_bytes = new.general.me_quota_soft_overshoot_bytes;
-    cfg.general.me_d2c_frame_buf_shrink_threshold_bytes =
-        new.general.me_d2c_frame_buf_shrink_threshold_bytes;
     cfg.general.direct_relay_copy_buf_c2s_bytes = new.general.direct_relay_copy_buf_c2s_bytes;
     cfg.general.direct_relay_copy_buf_s2c_bytes = new.general.direct_relay_copy_buf_s2c_bytes;
     cfg.general.me_health_interval_ms_unhealthy = new.general.me_health_interval_ms_unhealthy;
@@ -532,11 +381,9 @@ fn overlay_hot_fields(old: &ProxyConfig, new: &ProxyConfig) -> ProxyConfig {
     cfg.access.users = new.access.users.clone();
     cfg.access.user_ad_tags = new.access.user_ad_tags.clone();
     cfg.access.user_max_tcp_conns = new.access.user_max_tcp_conns.clone();
-    cfg.access.user_max_tcp_conns_global_each = new.access.user_max_tcp_conns_global_each;
     cfg.access.user_expirations = new.access.user_expirations.clone();
     cfg.access.user_data_quota = new.access.user_data_quota.clone();
     cfg.access.user_max_unique_ips = new.access.user_max_unique_ips.clone();
-    cfg.access.user_max_unique_ips_global_each = new.access.user_max_unique_ips_global_each;
     cfg.access.user_max_unique_ips_mode = new.access.user_max_unique_ips_mode;
     cfg.access.user_max_unique_ips_window_secs = new.access.user_max_unique_ips_window_secs;
 
@@ -562,7 +409,8 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
         || old.server.api.minimal_runtime_cache_ttl_ms
             != new.server.api.minimal_runtime_cache_ttl_ms
         || old.server.api.runtime_edge_enabled != new.server.api.runtime_edge_enabled
-        || old.server.api.runtime_edge_cache_ttl_ms != new.server.api.runtime_edge_cache_ttl_ms
+        || old.server.api.runtime_edge_cache_ttl_ms
+            != new.server.api.runtime_edge_cache_ttl_ms
         || old.server.api.runtime_edge_top_n != new.server.api.runtime_edge_top_n
         || old.server.api.runtime_edge_events_capacity
             != new.server.api.runtime_edge_events_capacity
@@ -573,7 +421,6 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
     }
     if old.server.proxy_protocol != new.server.proxy_protocol
         || !listeners_equal(&old.server.listeners, &new.server.listeners)
-        || old.server.listen_backlog != new.server.listen_backlog
         || old.server.listen_addr_ipv4 != new.server.listen_addr_ipv4
         || old.server.listen_addr_ipv6 != new.server.listen_addr_ipv6
         || old.server.listen_tcp != new.server.listen_tcp
@@ -585,7 +432,6 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
     }
     if old.censorship.tls_domain != new.censorship.tls_domain
         || old.censorship.tls_domains != new.censorship.tls_domains
-        || old.censorship.tls_fetch_scope != new.censorship.tls_fetch_scope
         || old.censorship.mask != new.censorship.mask
         || old.censorship.mask_host != new.censorship.mask_host
         || old.censorship.mask_port != new.censorship.mask_port
@@ -599,22 +445,6 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
         || old.censorship.tls_full_cert_ttl_secs != new.censorship.tls_full_cert_ttl_secs
         || old.censorship.alpn_enforce != new.censorship.alpn_enforce
         || old.censorship.mask_proxy_protocol != new.censorship.mask_proxy_protocol
-        || old.censorship.mask_shape_hardening != new.censorship.mask_shape_hardening
-        || old.censorship.mask_shape_bucket_floor_bytes
-            != new.censorship.mask_shape_bucket_floor_bytes
-        || old.censorship.mask_shape_bucket_cap_bytes != new.censorship.mask_shape_bucket_cap_bytes
-        || old.censorship.mask_shape_above_cap_blur != new.censorship.mask_shape_above_cap_blur
-        || old.censorship.mask_shape_above_cap_blur_max_bytes
-            != new.censorship.mask_shape_above_cap_blur_max_bytes
-        || old.censorship.mask_relay_max_bytes != new.censorship.mask_relay_max_bytes
-        || old.censorship.mask_classifier_prefetch_timeout_ms
-            != new.censorship.mask_classifier_prefetch_timeout_ms
-        || old.censorship.mask_timing_normalization_enabled
-            != new.censorship.mask_timing_normalization_enabled
-        || old.censorship.mask_timing_normalization_floor_ms
-            != new.censorship.mask_timing_normalization_floor_ms
-        || old.censorship.mask_timing_normalization_ceiling_ms
-            != new.censorship.mask_timing_normalization_ceiling_ms
     {
         warned = true;
         warn!("config reload: censorship settings changed; restart required");
@@ -655,9 +485,6 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
     }
     if old.general.me_route_no_writer_mode != new.general.me_route_no_writer_mode
         || old.general.me_route_no_writer_wait_ms != new.general.me_route_no_writer_wait_ms
-        || old.general.me_route_hybrid_max_wait_ms != new.general.me_route_hybrid_max_wait_ms
-        || old.general.me_route_blocking_send_timeout_ms
-            != new.general.me_route_blocking_send_timeout_ms
         || old.general.me_route_inline_recovery_attempts
             != new.general.me_route_inline_recovery_attempts
         || old.general.me_route_inline_recovery_wait_ms
@@ -676,11 +503,9 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
         warned = true;
         warn!("config reload: general.me_init_retry_attempts changed; restart required");
     }
-    if old.general.me2dc_fallback != new.general.me2dc_fallback
-        || old.general.me2dc_fast != new.general.me2dc_fast
-    {
+    if old.general.me2dc_fallback != new.general.me2dc_fallback {
         warned = true;
-        warn!("config reload: general.me2dc_fallback/me2dc_fast changed; restart required");
+        warn!("config reload: general.me2dc_fallback changed; restart required");
     }
     if old.general.proxy_config_v4_cache_path != new.general.proxy_config_v4_cache_path
         || old.general.proxy_config_v6_cache_path != new.general.proxy_config_v6_cache_path
@@ -699,7 +524,6 @@ fn warn_non_hot_changes(old: &ProxyConfig, new: &ProxyConfig, non_hot_changed: b
     if old.general.upstream_connect_retry_attempts != new.general.upstream_connect_retry_attempts
         || old.general.upstream_connect_retry_backoff_ms
             != new.general.upstream_connect_retry_backoff_ms
-        || old.general.tg_connect != new.general.tg_connect
         || old.general.upstream_unhealthy_fail_threshold
             != new.general.upstream_unhealthy_fail_threshold
         || old.general.upstream_connect_failfast_hard_errors
@@ -850,19 +674,6 @@ fn log_changes(
             old_hot.me_pool_drain_ttl_secs, new_hot.me_pool_drain_ttl_secs,
         );
     }
-    if old_hot.me_instadrain != new_hot.me_instadrain {
-        info!(
-            "config reload: me_instadrain: {} → {}",
-            old_hot.me_instadrain, new_hot.me_instadrain,
-        );
-    }
-
-    if old_hot.me_pool_drain_threshold != new_hot.me_pool_drain_threshold {
-        info!(
-            "config reload: me_pool_drain_threshold: {} → {}",
-            old_hot.me_pool_drain_threshold, new_hot.me_pool_drain_threshold,
-        );
-    }
 
     if (old_hot.me_pool_min_fresh_ratio - new_hot.me_pool_min_fresh_ratio).abs() > f32::EPSILON {
         info!(
@@ -896,7 +707,8 @@ fn log_changes(
     {
         info!(
             "config reload: me_bind_stale: mode={:?} ttl={}s",
-            new_hot.me_bind_stale_mode, new_hot.me_bind_stale_ttl_secs
+            new_hot.me_bind_stale_mode,
+            new_hot.me_bind_stale_ttl_secs
         );
     }
     if old_hot.me_secret_atomic_snapshot != new_hot.me_secret_atomic_snapshot
@@ -976,7 +788,8 @@ fn log_changes(
     if old_hot.me_socks_kdf_policy != new_hot.me_socks_kdf_policy {
         info!(
             "config reload: me_socks_kdf_policy: {:?} → {:?}",
-            old_hot.me_socks_kdf_policy, new_hot.me_socks_kdf_policy,
+            old_hot.me_socks_kdf_policy,
+            new_hot.me_socks_kdf_policy,
         );
     }
 
@@ -1030,7 +843,8 @@ fn log_changes(
         || old_hot.me_route_backpressure_high_watermark_pct
             != new_hot.me_route_backpressure_high_watermark_pct
         || old_hot.me_reader_route_data_wait_ms != new_hot.me_reader_route_data_wait_ms
-        || old_hot.me_health_interval_ms_unhealthy != new_hot.me_health_interval_ms_unhealthy
+        || old_hot.me_health_interval_ms_unhealthy
+            != new_hot.me_health_interval_ms_unhealthy
         || old_hot.me_health_interval_ms_healthy != new_hot.me_health_interval_ms_healthy
         || old_hot.me_admission_poll_ms != new_hot.me_admission_poll_ms
         || old_hot.me_warn_rate_limit_ms != new_hot.me_warn_rate_limit_ms
@@ -1052,47 +866,34 @@ fn log_changes(
         || old_hot.me_d2c_flush_batch_max_bytes != new_hot.me_d2c_flush_batch_max_bytes
         || old_hot.me_d2c_flush_batch_max_delay_us != new_hot.me_d2c_flush_batch_max_delay_us
         || old_hot.me_d2c_ack_flush_immediate != new_hot.me_d2c_ack_flush_immediate
-        || old_hot.me_quota_soft_overshoot_bytes != new_hot.me_quota_soft_overshoot_bytes
-        || old_hot.me_d2c_frame_buf_shrink_threshold_bytes
-            != new_hot.me_d2c_frame_buf_shrink_threshold_bytes
         || old_hot.direct_relay_copy_buf_c2s_bytes != new_hot.direct_relay_copy_buf_c2s_bytes
         || old_hot.direct_relay_copy_buf_s2c_bytes != new_hot.direct_relay_copy_buf_s2c_bytes
     {
         info!(
-            "config reload: relay_tuning: me_d2c_frames={} me_d2c_bytes={} me_d2c_delay_us={} me_ack_flush_immediate={} me_quota_soft_overshoot_bytes={} me_d2c_frame_buf_shrink_threshold_bytes={} direct_buf_c2s={} direct_buf_s2c={}",
+            "config reload: relay_tuning: me_d2c_frames={} me_d2c_bytes={} me_d2c_delay_us={} me_ack_flush_immediate={} direct_buf_c2s={} direct_buf_s2c={}",
             new_hot.me_d2c_flush_batch_max_frames,
             new_hot.me_d2c_flush_batch_max_bytes,
             new_hot.me_d2c_flush_batch_max_delay_us,
             new_hot.me_d2c_ack_flush_immediate,
-            new_hot.me_quota_soft_overshoot_bytes,
-            new_hot.me_d2c_frame_buf_shrink_threshold_bytes,
             new_hot.direct_relay_copy_buf_c2s_bytes,
             new_hot.direct_relay_copy_buf_s2c_bytes,
         );
     }
 
     if old_hot.users != new_hot.users {
-        let mut added: Vec<&String> = new_hot
-            .users
-            .keys()
+        let mut added: Vec<&String> = new_hot.users.keys()
             .filter(|u| !old_hot.users.contains_key(*u))
             .collect();
         added.sort();
 
-        let mut removed: Vec<&String> = old_hot
-            .users
-            .keys()
+        let mut removed: Vec<&String> = old_hot.users.keys()
             .filter(|u| !new_hot.users.contains_key(*u))
             .collect();
         removed.sort();
 
-        let mut changed: Vec<&String> = new_hot
-            .users
-            .keys()
+        let mut changed: Vec<&String> = new_hot.users.keys()
             .filter(|u| {
-                old_hot
-                    .users
-                    .get(*u)
+                old_hot.users.get(*u)
                     .map(|s| s != &new_hot.users[*u])
                     .unwrap_or(false)
             })
@@ -1102,18 +903,10 @@ fn log_changes(
         if !added.is_empty() {
             info!(
                 "config reload: users added: [{}]",
-                added
-                    .iter()
-                    .map(|s| s.as_str())
-                    .collect::<Vec<_>>()
-                    .join(", ")
+                added.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")
             );
             let host = resolve_link_host(new_cfg, detected_ip_v4, detected_ip_v6);
-            let port = new_cfg
-                .general
-                .links
-                .public_port
-                .unwrap_or(new_cfg.server.port);
+            let port = new_cfg.general.links.public_port.unwrap_or(new_cfg.server.port);
             for user in &added {
                 if let Some(secret) = new_hot.users.get(*user) {
                     print_user_links(user, secret, &host, port, new_cfg);
@@ -1123,21 +916,13 @@ fn log_changes(
         if !removed.is_empty() {
             info!(
                 "config reload: users removed: [{}]",
-                removed
-                    .iter()
-                    .map(|s| s.as_str())
-                    .collect::<Vec<_>>()
-                    .join(", ")
+                removed.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")
             );
         }
         if !changed.is_empty() {
             info!(
                 "config reload: users secret changed: [{}]",
-                changed
-                    .iter()
-                    .map(|s| s.as_str())
-                    .collect::<Vec<_>>()
-                    .join(", ")
+                changed.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")
             );
         }
     }
@@ -1148,12 +933,6 @@ fn log_changes(
             new_hot.user_max_tcp_conns.len()
         );
     }
-    if old_hot.user_max_tcp_conns_global_each != new_hot.user_max_tcp_conns_global_each {
-        info!(
-            "config reload: user_max_tcp_conns policy global_each={}",
-            new_hot.user_max_tcp_conns_global_each
-        );
-    }
     if old_hot.user_expirations != new_hot.user_expirations {
         info!(
             "config reload: user_expirations updated ({} entries)",
@@ -1172,13 +951,12 @@ fn log_changes(
             new_hot.user_max_unique_ips.len()
         );
     }
-    if old_hot.user_max_unique_ips_global_each != new_hot.user_max_unique_ips_global_each
-        || old_hot.user_max_unique_ips_mode != new_hot.user_max_unique_ips_mode
-        || old_hot.user_max_unique_ips_window_secs != new_hot.user_max_unique_ips_window_secs
+    if old_hot.user_max_unique_ips_mode != new_hot.user_max_unique_ips_mode
+        || old_hot.user_max_unique_ips_window_secs
+            != new_hot.user_max_unique_ips_window_secs
     {
         info!(
-            "config reload: user_max_unique_ips policy global_each={} mode={:?} window={}s",
-            new_hot.user_max_unique_ips_global_each,
+            "config reload: user_max_unique_ips policy mode={:?} window={}s",
             new_hot.user_max_unique_ips_mode,
             new_hot.user_max_unique_ips_window_secs
         );
@@ -1192,32 +970,18 @@ fn reload_config(
     log_tx: &watch::Sender<LogLevel>,
     detected_ip_v4: Option<IpAddr>,
     detected_ip_v6: Option<IpAddr>,
-    reload_state: &mut ReloadState,
-) -> Option<WatchManifest> {
-    let loaded = match ProxyConfig::load_with_metadata(config_path) {
-        Ok(loaded) => loaded,
+) {
+    let new_cfg = match ProxyConfig::load(config_path) {
+        Ok(c) => c,
         Err(e) => {
             error!("config reload: failed to parse {:?}: {}", config_path, e);
-            return None;
+            return;
         }
     };
-    let LoadedConfig {
-        config: new_cfg,
-        source_files,
-        rendered_hash,
-    } = loaded;
-    let next_manifest = WatchManifest::from_source_files(&source_files);
 
     if let Err(e) = new_cfg.validate() {
-        error!(
-            "config reload: validation failed: {}; keeping old config",
-            e
-        );
-        return Some(next_manifest);
-    }
-
-    if reload_state.is_applied(rendered_hash) {
-        return Some(next_manifest);
+        error!("config reload: validation failed: {}; keeping old config", e);
+        return;
     }
 
     let old_cfg = config_tx.borrow().clone();
@@ -1232,8 +996,7 @@ fn reload_config(
     }
 
     if !hot_changed {
-        reload_state.mark_applied(rendered_hash);
-        return Some(next_manifest);
+        return;
     }
 
     if old_hot.dns_overrides != applied_hot.dns_overrides
@@ -1243,7 +1006,7 @@ fn reload_config(
             "config reload: invalid network.dns_overrides: {}; keeping old config",
             e
         );
-        return Some(next_manifest);
+        return;
     }
 
     log_changes(
@@ -1255,8 +1018,6 @@ fn reload_config(
         detected_ip_v6,
     );
     config_tx.send(Arc::new(applied_cfg)).ok();
-    reload_state.mark_applied(rendered_hash);
-    Some(next_manifest)
 }
 
 // ── Public API ────────────────────────────────────────────────────────────────
@@ -1279,93 +1040,80 @@ pub fn spawn_config_watcher(
     let (config_tx, config_rx) = watch::channel(initial);
     let (log_tx, log_rx)       = watch::channel(initial_level);
 
-    let config_path = normalize_watch_path(&config_path);
-    let initial_loaded = ProxyConfig::load_with_metadata(&config_path).ok();
-    let initial_manifest = initial_loaded
-        .as_ref()
-        .map(|loaded| WatchManifest::from_source_files(&loaded.source_files))
-        .unwrap_or_else(|| WatchManifest::from_source_files(std::slice::from_ref(&config_path)));
-    let initial_snapshot_hash = initial_loaded.as_ref().map(|loaded| loaded.rendered_hash);
-
-    tokio::spawn(async move {
+    // Bridge: sync notify callbacks → async task via mpsc.
     let (notify_tx, mut notify_rx) = mpsc::channel::<()>(4);
-        let manifest_state = Arc::new(StdRwLock::new(WatchManifest::default()));
-        let mut reload_state = ReloadState::new(initial_snapshot_hash);
 
+    // Canonicalize so path matches what notify returns (absolute) in events.
+    let config_path = match config_path.canonicalize() {
+        Ok(p) => p,
+        Err(_) => config_path.to_path_buf(),
+    };
+
+    // Watch the parent directory rather than the file itself, because many
+    // editors (vim, nano) and systemd write via rename, which would cause
+    // inotify to lose track of the original inode.
+    let watch_dir = config_path
+        .parent()
+        .unwrap_or_else(|| std::path::Path::new("."))
+        .to_path_buf();
+
+    // ── inotify watcher (instant on local fs) ────────────────────────────
+    let config_file = config_path.clone();
     let tx_inotify  = notify_tx.clone();
-        let manifest_for_inotify = manifest_state.clone();
-        let mut inotify_watcher =
-            match recommended_watcher(move |res: notify::Result<notify::Event>| {
+    let inotify_ok = match recommended_watcher(move |res: notify::Result<notify::Event>| {
         let Ok(event) = res else { return };
-                if !matches!(
-                    event.kind,
-                    EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
-                ) {
-                    return;
-                }
-                let is_our_file = manifest_for_inotify
-                    .read()
-                    .map(|manifest| manifest.matches_event_paths(&event.paths))
-                    .unwrap_or(false);
-                if is_our_file {
+        let is_our_file = event.paths.iter().any(|p| p == &config_file);
+        if !is_our_file { return; }
+        if matches!(event.kind, EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)) {
             let _ = tx_inotify.try_send(());
         }
     }) {
-                Ok(watcher) => Some(watcher),
-                Err(e) => {
-                    warn!("config watcher: inotify unavailable: {}", e);
-                    None
-                }
-            };
-        apply_watch_manifest(
-            inotify_watcher.as_mut(),
-            Option::<&mut notify::poll::PollWatcher>::None,
-            &manifest_state,
-            initial_manifest.clone(),
-        );
-        if inotify_watcher.is_some() {
+        Ok(mut w) => match w.watch(&watch_dir, RecursiveMode::NonRecursive) {
+            Ok(()) => {
                 info!("config watcher: inotify active on {:?}", config_path);
+                Box::leak(Box::new(w));
+                true
             }
+            Err(e) => { warn!("config watcher: inotify watch failed: {}", e); false }
+        },
+        Err(e) => { warn!("config watcher: inotify unavailable: {}", e); false }
+    };
 
+    // ── poll watcher (always active, fixes Docker bind mounts / NFS) ─────
+    // inotify does not receive events for files mounted from the host into
+    // a container. PollWatcher compares file contents every 3 s and fires
+    // on any change regardless of the underlying fs.
+    let config_file2 = config_path.clone();
     let tx_poll      = notify_tx.clone();
-        let manifest_for_poll = manifest_state.clone();
-        let mut poll_watcher = match notify::poll::PollWatcher::new(
+    match notify::poll::PollWatcher::new(
         move |res: notify::Result<notify::Event>| {
             let Ok(event) = res else { return };
-                if !matches!(
-                    event.kind,
-                    EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
-                ) {
-                    return;
-                }
-                let is_our_file = manifest_for_poll
-                    .read()
-                    .map(|manifest| manifest.matches_event_paths(&event.paths))
-                    .unwrap_or(false);
-                if is_our_file {
+            let is_our_file = event.paths.iter().any(|p| p == &config_file2);
+            if !is_our_file { return; }
+            if matches!(event.kind, EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)) {
                 let _ = tx_poll.try_send(());
             }
         },
         notify::Config::default()
-                .with_poll_interval(Duration::from_secs(3))
+            .with_poll_interval(std::time::Duration::from_secs(3))
             .with_compare_contents(true),
     ) {
-            Ok(watcher) => Some(watcher),
-            Err(e) => {
-                warn!("config watcher: poll watcher unavailable: {}", e);
-                None
+        Ok(mut w) => match w.watch(&config_path, RecursiveMode::NonRecursive) {
+            Ok(()) => {
+                if inotify_ok {
+                    info!("config watcher: poll watcher also active (Docker/NFS safe)");
+                } else {
+                    info!("config watcher: poll watcher active on {:?} (3s interval)", config_path);
                 }
-        };
-        apply_watch_manifest(
-            Option::<&mut notify::RecommendedWatcher>::None,
-            poll_watcher.as_mut(),
-            &manifest_state,
-            initial_manifest.clone(),
-        );
-        if poll_watcher.is_some() {
-            info!("config watcher: poll watcher active (Docker/NFS safe)");
+                Box::leak(Box::new(w));
+            }
+            Err(e) => warn!("config watcher: poll watch failed: {}", e),
+        },
+        Err(e) => warn!("config watcher: poll watcher unavailable: {}", e),
     }
 
+    // ── event loop ───────────────────────────────────────────────────────
+    tokio::spawn(async move {
         #[cfg(unix)]
         let mut sighup = {
             use tokio::signal::unix::{SignalKind, signal};
@@ -1383,43 +1131,13 @@ pub fn spawn_config_watcher(
                 }
             }
             #[cfg(not(unix))]
-            if notify_rx.recv().await.is_none() {
-                break;
-            }
+            if notify_rx.recv().await.is_none() { break; }
 
-            // Debounce: drain extra events that arrive within a short quiet window.
-            tokio::time::sleep(HOT_RELOAD_DEBOUNCE).await;
+            // Debounce: drain extra events that arrive within 50 ms.
+            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
             while notify_rx.try_recv().is_ok() {}
 
-            let mut next_manifest = reload_config(
-                &config_path,
-                &config_tx,
-                &log_tx,
-                detected_ip_v4,
-                detected_ip_v6,
-                &mut reload_state,
-            );
-            if next_manifest.is_none() {
-                tokio::time::sleep(HOT_RELOAD_DEBOUNCE).await;
-                while notify_rx.try_recv().is_ok() {}
-                next_manifest = reload_config(
-                    &config_path,
-                    &config_tx,
-                    &log_tx,
-                    detected_ip_v4,
-                    detected_ip_v6,
-                    &mut reload_state,
-                );
-            }
-
-            if let Some(next_manifest) = next_manifest {
-                apply_watch_manifest(
-                    inotify_watcher.as_mut(),
-                    poll_watcher.as_mut(),
-                    &manifest_state,
-                    next_manifest,
-                );
-            }
+            reload_config(&config_path, &config_tx, &log_tx, detected_ip_v4, detected_ip_v6);
         }
     });
 
@@ -1434,40 +1152,6 @@ mod tests {
         ProxyConfig::default()
     }
 
-    fn write_reload_config(path: &Path, ad_tag: Option<&str>, server_port: Option<u16>) {
-        let mut config = String::from(
-            r#"
-                [censorship]
-                tls_domain = "example.com"
-
-                [access.users]
-                user = "00000000000000000000000000000000"
-            "#,
-        );
-
-        if ad_tag.is_some() {
-            config.push_str("\n[general]\n");
-            if let Some(tag) = ad_tag {
-                config.push_str(&format!("ad_tag = \"{tag}\"\n"));
-            }
-        }
-
-        if let Some(port) = server_port {
-            config.push_str("\n[server]\n");
-            config.push_str(&format!("port = {port}\n"));
-        }
-
-        std::fs::write(path, config).unwrap();
-    }
-
-    fn temp_config_path(prefix: &str) -> PathBuf {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        std::env::temp_dir().join(format!("{prefix}_{nonce}.toml"))
-    }
-
     #[test]
     fn overlay_applies_hot_and_preserves_non_hot() {
         let old = sample_config();
@@ -1487,10 +1171,7 @@ mod tests {
         new.server.port = old.server.port.saturating_add(1);
 
         let applied = overlay_hot_fields(&old, &new);
-        assert_eq!(
-            HotFields::from_config(&old),
-            HotFields::from_config(&applied)
-        );
+        assert_eq!(HotFields::from_config(&old), HotFields::from_config(&applied));
         assert_eq!(applied.server.port, old.server.port);
     }
 
@@ -1509,10 +1190,7 @@ mod tests {
             applied.general.me_bind_stale_mode,
             new.general.me_bind_stale_mode
         );
-        assert_ne!(
-            HotFields::from_config(&old),
-            HotFields::from_config(&applied)
-        );
+        assert_ne!(HotFields::from_config(&old), HotFields::from_config(&applied));
     }
 
     #[test]
@@ -1526,10 +1204,7 @@ mod tests {
             applied.general.me_keepalive_interval_secs,
             old.general.me_keepalive_interval_secs
         );
-        assert_eq!(
-            HotFields::from_config(&old),
-            HotFields::from_config(&applied)
-        );
+        assert_eq!(HotFields::from_config(&old), HotFields::from_config(&applied));
     }
 
     #[test]
@@ -1541,92 +1216,7 @@ mod tests {
 
         let applied = overlay_hot_fields(&old, &new);
         assert_eq!(applied.general.hardswap, new.general.hardswap);
-        assert_eq!(
-            applied.general.use_middle_proxy,
-            old.general.use_middle_proxy
-        );
+        assert_eq!(applied.general.use_middle_proxy, old.general.use_middle_proxy);
         assert!(!config_equal(&applied, &new));
     }
-
-    #[test]
-    fn reload_applies_hot_change_on_first_observed_snapshot() {
-        let initial_tag = "11111111111111111111111111111111";
-        let final_tag = "22222222222222222222222222222222";
-        let path = temp_config_path("telemt_hot_reload_stable");
-
-        write_reload_config(&path, Some(initial_tag), None);
-        let initial_cfg = Arc::new(ProxyConfig::load(&path).unwrap());
-        let initial_hash = ProxyConfig::load_with_metadata(&path)
-            .unwrap()
-            .rendered_hash;
-        let (config_tx, _config_rx) = watch::channel(initial_cfg.clone());
-        let (log_tx, _log_rx) = watch::channel(initial_cfg.general.log_level.clone());
-        let mut reload_state = ReloadState::new(Some(initial_hash));
-
-        write_reload_config(&path, Some(final_tag), None);
-        reload_config(&path, &config_tx, &log_tx, None, None, &mut reload_state).unwrap();
-        assert_eq!(
-            config_tx.borrow().general.ad_tag.as_deref(),
-            Some(final_tag)
-        );
-
-        let _ = std::fs::remove_file(path);
-    }
-
-    #[test]
-    fn reload_keeps_hot_apply_when_non_hot_fields_change() {
-        let initial_tag = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-        let final_tag = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
-        let path = temp_config_path("telemt_hot_reload_mixed");
-
-        write_reload_config(&path, Some(initial_tag), None);
-        let initial_cfg = Arc::new(ProxyConfig::load(&path).unwrap());
-        let initial_hash = ProxyConfig::load_with_metadata(&path)
-            .unwrap()
-            .rendered_hash;
-        let (config_tx, _config_rx) = watch::channel(initial_cfg.clone());
-        let (log_tx, _log_rx) = watch::channel(initial_cfg.general.log_level.clone());
-        let mut reload_state = ReloadState::new(Some(initial_hash));
-
-        write_reload_config(&path, Some(final_tag), Some(initial_cfg.server.port + 1));
-        reload_config(&path, &config_tx, &log_tx, None, None, &mut reload_state).unwrap();
-
-        let applied = config_tx.borrow().clone();
-        assert_eq!(applied.general.ad_tag.as_deref(), Some(final_tag));
-        assert_eq!(applied.server.port, initial_cfg.server.port);
-
-        let _ = std::fs::remove_file(path);
-    }
-
-    #[test]
-    fn reload_recovers_after_parse_error_on_next_attempt() {
-        let initial_tag = "cccccccccccccccccccccccccccccccc";
-        let final_tag = "dddddddddddddddddddddddddddddddd";
-        let path = temp_config_path("telemt_hot_reload_parse_recovery");
-
-        write_reload_config(&path, Some(initial_tag), None);
-        let initial_cfg = Arc::new(ProxyConfig::load(&path).unwrap());
-        let initial_hash = ProxyConfig::load_with_metadata(&path)
-            .unwrap()
-            .rendered_hash;
-        let (config_tx, _config_rx) = watch::channel(initial_cfg.clone());
-        let (log_tx, _log_rx) = watch::channel(initial_cfg.general.log_level.clone());
-        let mut reload_state = ReloadState::new(Some(initial_hash));
-
-        std::fs::write(&path, "[access.users\nuser = \"broken\"\n").unwrap();
-        assert!(reload_config(&path, &config_tx, &log_tx, None, None, &mut reload_state).is_none());
-        assert_eq!(
-            config_tx.borrow().general.ad_tag.as_deref(),
-            Some(initial_tag)
-        );
-
-        write_reload_config(&path, Some(final_tag), None);
-        reload_config(&path, &config_tx, &log_tx, None, None, &mut reload_state).unwrap();
-        assert_eq!(
-            config_tx.borrow().general.ad_tag.as_deref(),
-            Some(final_tag)
-        );
-
-        let _ = std::fs::remove_file(path);
-    }
 }

src/config/mod.rs

@@ -1,9 +1,9 @@
 //! Configuration.
 
 pub(crate) mod defaults;
-pub mod hot_reload;
-mod load;
 mod types;
+mod load;
+pub mod hot_reload;
 
 pub use load::ProxyConfig;
 pub use types::*;

src/config/tests/load_idle_policy_tests.rs

@@ -1,102 +0,0 @@
-use super::*;
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn write_temp_config(contents: &str) -> PathBuf {
-    let nonce = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("system time must be after unix epoch")
-        .as_nanos();
-    let path = std::env::temp_dir().join(format!("telemt-idle-policy-{nonce}.toml"));
-    fs::write(&path, contents).expect("temp config write must succeed");
-    path
-}
-
-fn remove_temp_config(path: &PathBuf) {
-    let _ = fs::remove_file(path);
-}
-
-#[test]
-fn default_timeouts_enable_apple_compatible_handshake_profile() {
-    let cfg = ProxyConfig::default();
-    assert_eq!(cfg.timeouts.client_first_byte_idle_secs, 300);
-    assert_eq!(cfg.timeouts.client_handshake, 60);
-}
-
-#[test]
-fn load_accepts_zero_first_byte_idle_timeout_as_legacy_opt_out() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-client_first_byte_idle_secs = 0
-"#,
-    );
-
-    let cfg = ProxyConfig::load(&path).expect("config with zero first-byte idle timeout must load");
-    assert_eq!(cfg.timeouts.client_first_byte_idle_secs, 0);
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_relay_hard_idle_smaller_than_soft_idle_with_clear_error() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-relay_client_idle_soft_secs = 120
-relay_client_idle_hard_secs = 60
-"#,
-    );
-
-    let err = ProxyConfig::load(&path).expect_err("config with hard<soft must fail");
-    let msg = err.to_string();
-    assert!(
-        msg.contains(
-            "timeouts.relay_client_idle_hard_secs must be >= timeouts.relay_client_idle_soft_secs"
-        ),
-        "error must explain the violated hard>=soft invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_relay_grace_larger_than_hard_idle_with_clear_error() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-relay_client_idle_soft_secs = 60
-relay_client_idle_hard_secs = 120
-relay_idle_grace_after_downstream_activity_secs = 121
-"#,
-    );
-
-    let err = ProxyConfig::load(&path).expect_err("config with grace>hard must fail");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("timeouts.relay_idle_grace_after_downstream_activity_secs must be <= timeouts.relay_client_idle_hard_secs"),
-        "error must explain the violated grace<=hard invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_zero_handshake_timeout_with_clear_error() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-client_handshake = 0
-"#,
-    );
-
-    let err = ProxyConfig::load(&path).expect_err("config with zero handshake timeout must fail");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("timeouts.client_handshake must be > 0"),
-        "error must explain that handshake timeout must be positive, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}

src/config/tests/load_mask_classifier_prefetch_timeout_security_tests.rs

@@ -1,76 +0,0 @@
-use super::*;
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn write_temp_config(contents: &str) -> PathBuf {
-    let nonce = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("system time must be after unix epoch")
-        .as_nanos();
-    let path = std::env::temp_dir().join(format!(
-        "telemt-load-mask-prefetch-timeout-security-{nonce}.toml"
-    ));
-    fs::write(&path, contents).expect("temp config write must succeed");
-    path
-}
-
-fn remove_temp_config(path: &PathBuf) {
-    let _ = fs::remove_file(path);
-}
-
-#[test]
-fn load_rejects_mask_classifier_prefetch_timeout_below_min_bound() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_classifier_prefetch_timeout_ms = 4
-"#,
-    );
-
-    let err = ProxyConfig::load(&path)
-        .expect_err("prefetch timeout below minimum security bound must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_classifier_prefetch_timeout_ms must be within [5, 50]"),
-        "error must explain timeout bound invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_mask_classifier_prefetch_timeout_above_max_bound() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_classifier_prefetch_timeout_ms = 51
-"#,
-    );
-
-    let err = ProxyConfig::load(&path)
-        .expect_err("prefetch timeout above max security bound must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_classifier_prefetch_timeout_ms must be within [5, 50]"),
-        "error must explain timeout bound invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_mask_classifier_prefetch_timeout_within_bounds() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_classifier_prefetch_timeout_ms = 20
-"#,
-    );
-
-    let cfg =
-        ProxyConfig::load(&path).expect("prefetch timeout within security bounds must be accepted");
-    assert_eq!(cfg.censorship.mask_classifier_prefetch_timeout_ms, 20);
-
-    remove_temp_config(&path);
-}

src/config/tests/load_mask_shape_security_tests.rs

@@ -1,292 +0,0 @@
-use super::*;
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn write_temp_config(contents: &str) -> PathBuf {
-    let nonce = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("system time must be after unix epoch")
-        .as_nanos();
-    let path = std::env::temp_dir().join(format!("telemt-load-mask-shape-security-{nonce}.toml"));
-    fs::write(&path, contents).expect("temp config write must succeed");
-    path
-}
-
-fn remove_temp_config(path: &PathBuf) {
-    let _ = fs::remove_file(path);
-}
-
-#[test]
-fn load_rejects_zero_mask_shape_bucket_floor_bytes() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_bucket_floor_bytes = 0
-mask_shape_bucket_cap_bytes = 4096
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("zero mask_shape_bucket_floor_bytes must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_shape_bucket_floor_bytes must be > 0"),
-        "error must explain floor>0 invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_mask_shape_bucket_cap_less_than_floor() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_bucket_floor_bytes = 1024
-mask_shape_bucket_cap_bytes = 512
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("mask_shape_bucket_cap_bytes < floor must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains(
-            "censorship.mask_shape_bucket_cap_bytes must be >= censorship.mask_shape_bucket_floor_bytes"
-        ),
-        "error must explain cap>=floor invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_mask_shape_bucket_cap_equal_to_floor() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = true
-mask_shape_bucket_floor_bytes = 1024
-mask_shape_bucket_cap_bytes = 1024
-"#,
-    );
-
-    let cfg = ProxyConfig::load(&path).expect("equal cap and floor must be accepted");
-    assert!(cfg.censorship.mask_shape_hardening);
-    assert_eq!(cfg.censorship.mask_shape_bucket_floor_bytes, 1024);
-    assert_eq!(cfg.censorship.mask_shape_bucket_cap_bytes, 1024);
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_above_cap_blur_when_shape_hardening_disabled() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = false
-mask_shape_above_cap_blur = true
-mask_shape_above_cap_blur_max_bytes = 64
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("above-cap blur must require shape hardening enabled");
-    let msg = err.to_string();
-    assert!(
-        msg.contains(
-            "censorship.mask_shape_above_cap_blur requires censorship.mask_shape_hardening = true"
-        ),
-        "error must explain blur prerequisite, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_above_cap_blur_with_zero_max_bytes() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = true
-mask_shape_above_cap_blur = true
-mask_shape_above_cap_blur_max_bytes = 0
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("above-cap blur max bytes must be > 0 when enabled");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_shape_above_cap_blur_max_bytes must be > 0 when censorship.mask_shape_above_cap_blur is enabled"),
-        "error must explain blur max bytes invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_timing_normalization_floor_zero_when_enabled() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_timing_normalization_enabled = true
-mask_timing_normalization_floor_ms = 0
-mask_timing_normalization_ceiling_ms = 200
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("timing normalization floor must be > 0 when enabled");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_timing_normalization_floor_ms must be > 0 when censorship.mask_timing_normalization_enabled is true"),
-        "error must explain timing floor invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_timing_normalization_ceiling_below_floor() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_timing_normalization_enabled = true
-mask_timing_normalization_floor_ms = 220
-mask_timing_normalization_ceiling_ms = 200
-"#,
-    );
-
-    let err = ProxyConfig::load(&path).expect_err("timing normalization ceiling must be >= floor");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_timing_normalization_ceiling_ms must be >= censorship.mask_timing_normalization_floor_ms"),
-        "error must explain timing ceiling/floor invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_valid_timing_normalization_and_above_cap_blur_config() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = true
-mask_shape_above_cap_blur = true
-mask_shape_above_cap_blur_max_bytes = 128
-mask_timing_normalization_enabled = true
-mask_timing_normalization_floor_ms = 150
-mask_timing_normalization_ceiling_ms = 240
-"#,
-    );
-
-    let cfg = ProxyConfig::load(&path)
-        .expect("valid blur and timing normalization settings must be accepted");
-    assert!(cfg.censorship.mask_shape_hardening);
-    assert!(cfg.censorship.mask_shape_above_cap_blur);
-    assert_eq!(cfg.censorship.mask_shape_above_cap_blur_max_bytes, 128);
-    assert!(cfg.censorship.mask_timing_normalization_enabled);
-    assert_eq!(cfg.censorship.mask_timing_normalization_floor_ms, 150);
-    assert_eq!(cfg.censorship.mask_timing_normalization_ceiling_ms, 240);
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_aggressive_shape_mode_when_shape_hardening_disabled() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = false
-mask_shape_hardening_aggressive_mode = true
-"#,
-    );
-
-    let err = ProxyConfig::load(&path)
-        .expect_err("aggressive shape hardening mode must require shape hardening enabled");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_shape_hardening_aggressive_mode requires censorship.mask_shape_hardening = true"),
-        "error must explain aggressive-mode prerequisite, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_aggressive_shape_mode_when_shape_hardening_enabled() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_shape_hardening = true
-mask_shape_hardening_aggressive_mode = true
-mask_shape_above_cap_blur = true
-mask_shape_above_cap_blur_max_bytes = 8
-"#,
-    );
-
-    let cfg = ProxyConfig::load(&path)
-        .expect("aggressive shape hardening mode should be accepted when prerequisites are met");
-    assert!(cfg.censorship.mask_shape_hardening);
-    assert!(cfg.censorship.mask_shape_hardening_aggressive_mode);
-    assert!(cfg.censorship.mask_shape_above_cap_blur);
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_zero_mask_relay_max_bytes() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_relay_max_bytes = 0
-"#,
-    );
-
-    let err = ProxyConfig::load(&path).expect_err("mask_relay_max_bytes must be > 0");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_relay_max_bytes must be > 0"),
-        "error must explain non-zero relay cap invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_mask_relay_max_bytes_above_upper_bound() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_relay_max_bytes = 67108865
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("mask_relay_max_bytes above hard cap must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains("censorship.mask_relay_max_bytes must be <= 67108864"),
-        "error must explain relay cap upper bound invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_valid_mask_relay_max_bytes() {
-    let path = write_temp_config(
-        r#"
-[censorship]
-mask_relay_max_bytes = 8388608
-"#,
-    );
-
-    let cfg = ProxyConfig::load(&path).expect("valid mask_relay_max_bytes must be accepted");
-    assert_eq!(cfg.censorship.mask_relay_max_bytes, 8_388_608);
-
-    remove_temp_config(&path);
-}

src/config/tests/load_security_tests.rs

@@ -1,88 +0,0 @@
-use super::*;
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn write_temp_config(contents: &str) -> PathBuf {
-    let nonce = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("system time must be after unix epoch")
-        .as_nanos();
-    let path = std::env::temp_dir().join(format!("telemt-load-security-{nonce}.toml"));
-    fs::write(&path, contents).expect("temp config write must succeed");
-    path
-}
-
-fn remove_temp_config(path: &PathBuf) {
-    let _ = fs::remove_file(path);
-}
-
-#[test]
-fn load_rejects_server_hello_delay_equal_to_handshake_timeout_budget() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-client_handshake = 1
-
-[censorship]
-server_hello_delay_max_ms = 1000
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("delay equal to handshake timeout must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains(
-            "censorship.server_hello_delay_max_ms must be < timeouts.client_handshake * 1000"
-        ),
-        "error must explain delay<timeout invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_rejects_server_hello_delay_larger_than_handshake_timeout_budget() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-client_handshake = 1
-
-[censorship]
-server_hello_delay_max_ms = 1500
-"#,
-    );
-
-    let err =
-        ProxyConfig::load(&path).expect_err("delay larger than handshake timeout must be rejected");
-    let msg = err.to_string();
-    assert!(
-        msg.contains(
-            "censorship.server_hello_delay_max_ms must be < timeouts.client_handshake * 1000"
-        ),
-        "error must explain delay<timeout invariant, got: {msg}"
-    );
-
-    remove_temp_config(&path);
-}
-
-#[test]
-fn load_accepts_server_hello_delay_strictly_below_handshake_timeout_budget() {
-    let path = write_temp_config(
-        r#"
-[timeouts]
-client_handshake = 1
-
-[censorship]
-server_hello_delay_max_ms = 999
-"#,
-    );
-
-    let cfg =
-        ProxyConfig::load(&path).expect("delay below handshake timeout budget must be accepted");
-    assert_eq!(cfg.timeouts.client_handshake, 1);
-    assert_eq!(cfg.censorship.server_hello_delay_max_ms, 999);
-
-    remove_temp_config(&path);
-}

src/config/types.rs

@@ -3,7 +3,6 @@ use ipnetwork::IpNetwork;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::net::IpAddr;
-use std::path::PathBuf;
 
 use super::defaults::*;
 
@@ -135,8 +134,8 @@ impl MeSocksKdfPolicy {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "lowercase")]
 pub enum MeBindStaleMode {
-    #[default]
     Never,
+    #[default]
     Ttl,
     Always,
 }
@@ -357,9 +356,6 @@ impl Default for NetworkConfig {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GeneralConfig {
-    #[serde(default)]
-    pub data_path: Option<PathBuf>,
-
     #[serde(default)]
     pub modes: ProxyModes,
 
@@ -429,11 +425,6 @@ pub struct GeneralConfig {
     #[serde(default = "default_me2dc_fallback")]
     pub me2dc_fallback: bool,
 
-    /// Fast ME->Direct fallback mode for new sessions.
-    /// Active only when both `use_middle_proxy=true` and `me2dc_fallback=true`.
-    #[serde(default = "default_me2dc_fast")]
-    pub me2dc_fast: bool,
-
     /// Enable ME keepalive padding frames.
     #[serde(default = "default_true")]
     pub me_keepalive_enabled: bool,
@@ -467,13 +458,8 @@ pub struct GeneralConfig {
     #[serde(default = "default_me_c2me_channel_capacity")]
     pub me_c2me_channel_capacity: usize,
 
-    /// Maximum wait in milliseconds for enqueueing C2ME commands when the queue is full.
-    /// `0` keeps legacy unbounded wait behavior.
-    #[serde(default = "default_me_c2me_send_timeout_ms")]
-    pub me_c2me_send_timeout_ms: u64,
-
     /// Bounded wait in milliseconds for routing ME DATA to per-connection queue.
-    /// `0` keeps non-blocking routing; values >0 enable bounded wait for compatibility.
+    /// `0` keeps legacy no-wait behavior.
     #[serde(default = "default_me_reader_route_data_wait_ms")]
     pub me_reader_route_data_wait_ms: u64,
 
@@ -494,14 +480,6 @@ pub struct GeneralConfig {
     #[serde(default = "default_me_d2c_ack_flush_immediate")]
     pub me_d2c_ack_flush_immediate: bool,
 
-    /// Additional bytes above strict per-user quota allowed in hot-path soft mode.
-    #[serde(default = "default_me_quota_soft_overshoot_bytes")]
-    pub me_quota_soft_overshoot_bytes: u64,
-
-    /// Shrink threshold for reusable ME->Client frame assembly buffer.
-    #[serde(default = "default_me_d2c_frame_buf_shrink_threshold_bytes")]
-    pub me_d2c_frame_buf_shrink_threshold_bytes: usize,
-
     /// Copy buffer size for client->DC direction in direct relay.
     #[serde(default = "default_direct_relay_copy_buf_c2s_bytes")]
     pub direct_relay_copy_buf_c2s_bytes: usize,
@@ -663,10 +641,6 @@ pub struct GeneralConfig {
     #[serde(default = "default_upstream_connect_budget_ms")]
     pub upstream_connect_budget_ms: u64,
 
-    /// Per-attempt TCP connect timeout to Telegram DC (seconds).
-    #[serde(default = "default_connect_timeout")]
-    pub tg_connect: u64,
-
     /// Consecutive failed requests before upstream is marked unhealthy.
     #[serde(default = "default_upstream_unhealthy_fail_threshold")]
     pub upstream_unhealthy_fail_threshold: u32,
@@ -738,15 +712,6 @@ pub struct GeneralConfig {
     #[serde(default = "default_me_route_no_writer_wait_ms")]
     pub me_route_no_writer_wait_ms: u64,
 
-    /// Maximum cumulative wait in milliseconds for hybrid no-writer mode before failfast.
-    #[serde(default = "default_me_route_hybrid_max_wait_ms")]
-    pub me_route_hybrid_max_wait_ms: u64,
-
-    /// Maximum wait in milliseconds for blocking ME writer channel send fallback.
-    /// `0` keeps legacy unbounded wait behavior.
-    #[serde(default = "default_me_route_blocking_send_timeout_ms")]
-    pub me_route_blocking_send_timeout_ms: u64,
-
     /// Number of inline recovery attempts in legacy mode.
     #[serde(default = "default_me_route_inline_recovery_attempts")]
     pub me_route_inline_recovery_attempts: u32,
@@ -829,35 +794,6 @@ pub struct GeneralConfig {
     #[serde(default = "default_me_pool_drain_ttl_secs")]
     pub me_pool_drain_ttl_secs: u64,
 
-    /// Force-remove any draining writer on the next cleanup tick, regardless of age/deadline.
-    #[serde(default = "default_me_instadrain")]
-    pub me_instadrain: bool,
-
-    /// Maximum allowed number of draining ME writers before oldest ones are force-closed in batches.
-    /// Set to 0 to disable threshold-based draining cleanup and keep timeout-only behavior.
-    #[serde(default = "default_me_pool_drain_threshold")]
-    pub me_pool_drain_threshold: u64,
-
-    /// Enable staged client eviction for draining ME writers that remain non-empty past TTL.
-    #[serde(default = "default_me_pool_drain_soft_evict_enabled")]
-    pub me_pool_drain_soft_evict_enabled: bool,
-
-    /// Extra grace in seconds after drain TTL before soft-eviction stage starts.
-    #[serde(default = "default_me_pool_drain_soft_evict_grace_secs")]
-    pub me_pool_drain_soft_evict_grace_secs: u64,
-
-    /// Maximum number of client sessions to evict from one draining writer per health tick.
-    #[serde(default = "default_me_pool_drain_soft_evict_per_writer")]
-    pub me_pool_drain_soft_evict_per_writer: u8,
-
-    /// Soft-eviction budget per CPU core for one health tick.
-    #[serde(default = "default_me_pool_drain_soft_evict_budget_per_core")]
-    pub me_pool_drain_soft_evict_budget_per_core: u16,
-
-    /// Cooldown for repetitive soft-eviction on the same writer in milliseconds.
-    #[serde(default = "default_me_pool_drain_soft_evict_cooldown_ms")]
-    pub me_pool_drain_soft_evict_cooldown_ms: u64,
-
     /// Policy for new binds on stale draining writers.
     #[serde(default)]
     pub me_bind_stale_mode: MeBindStaleMode,
@@ -872,7 +808,7 @@ pub struct GeneralConfig {
     pub me_pool_min_fresh_ratio: f32,
 
     /// Drain timeout in seconds for stale ME writers after endpoint map changes.
-    /// Set to 0 to use the runtime safety fallback timeout.
+    /// Set to 0 to keep stale writers draining indefinitely (no force-close).
     #[serde(default = "default_me_reinit_drain_timeout_secs")]
     pub me_reinit_drain_timeout_secs: u64,
 
@@ -930,7 +866,6 @@ pub struct GeneralConfig {
 impl Default for GeneralConfig {
     fn default() -> Self {
         Self {
-            data_path: None,
             modes: ProxyModes::default(),
             prefer_ipv6: false,
             fast_mode: default_true(),
@@ -948,7 +883,6 @@ impl Default for GeneralConfig {
             middle_proxy_warm_standby: default_middle_proxy_warm_standby(),
             me_init_retry_attempts: default_me_init_retry_attempts(),
             me2dc_fallback: default_me2dc_fallback(),
-            me2dc_fast: default_me2dc_fast(),
             me_keepalive_enabled: default_true(),
             me_keepalive_interval_secs: default_keepalive_interval(),
             me_keepalive_jitter_secs: default_keepalive_jitter(),
@@ -957,15 +891,11 @@ impl Default for GeneralConfig {
             me_writer_cmd_channel_capacity: default_me_writer_cmd_channel_capacity(),
             me_route_channel_capacity: default_me_route_channel_capacity(),
             me_c2me_channel_capacity: default_me_c2me_channel_capacity(),
-            me_c2me_send_timeout_ms: default_me_c2me_send_timeout_ms(),
             me_reader_route_data_wait_ms: default_me_reader_route_data_wait_ms(),
             me_d2c_flush_batch_max_frames: default_me_d2c_flush_batch_max_frames(),
             me_d2c_flush_batch_max_bytes: default_me_d2c_flush_batch_max_bytes(),
             me_d2c_flush_batch_max_delay_us: default_me_d2c_flush_batch_max_delay_us(),
             me_d2c_ack_flush_immediate: default_me_d2c_ack_flush_immediate(),
-            me_quota_soft_overshoot_bytes: default_me_quota_soft_overshoot_bytes(),
-            me_d2c_frame_buf_shrink_threshold_bytes:
-                default_me_d2c_frame_buf_shrink_threshold_bytes(),
             direct_relay_copy_buf_c2s_bytes: default_direct_relay_copy_buf_c2s_bytes(),
             direct_relay_copy_buf_s2c_bytes: default_direct_relay_copy_buf_s2c_bytes(),
             me_warmup_stagger_enabled: default_true(),
@@ -976,42 +906,27 @@ impl Default for GeneralConfig {
             me_reconnect_backoff_cap_ms: default_reconnect_backoff_cap_ms(),
             me_reconnect_fast_retry_count: default_me_reconnect_fast_retry_count(),
             me_single_endpoint_shadow_writers: default_me_single_endpoint_shadow_writers(),
-            me_single_endpoint_outage_mode_enabled: default_me_single_endpoint_outage_mode_enabled(
-            ),
-            me_single_endpoint_outage_disable_quarantine:
-                default_me_single_endpoint_outage_disable_quarantine(),
-            me_single_endpoint_outage_backoff_min_ms:
-                default_me_single_endpoint_outage_backoff_min_ms(),
-            me_single_endpoint_outage_backoff_max_ms:
-                default_me_single_endpoint_outage_backoff_max_ms(),
-            me_single_endpoint_shadow_rotate_every_secs:
-                default_me_single_endpoint_shadow_rotate_every_secs(),
+            me_single_endpoint_outage_mode_enabled: default_me_single_endpoint_outage_mode_enabled(),
+            me_single_endpoint_outage_disable_quarantine: default_me_single_endpoint_outage_disable_quarantine(),
+            me_single_endpoint_outage_backoff_min_ms: default_me_single_endpoint_outage_backoff_min_ms(),
+            me_single_endpoint_outage_backoff_max_ms: default_me_single_endpoint_outage_backoff_max_ms(),
+            me_single_endpoint_shadow_rotate_every_secs: default_me_single_endpoint_shadow_rotate_every_secs(),
             me_floor_mode: MeFloorMode::default(),
             me_adaptive_floor_idle_secs: default_me_adaptive_floor_idle_secs(),
-            me_adaptive_floor_min_writers_single_endpoint:
-                default_me_adaptive_floor_min_writers_single_endpoint(),
-            me_adaptive_floor_min_writers_multi_endpoint:
-                default_me_adaptive_floor_min_writers_multi_endpoint(),
+            me_adaptive_floor_min_writers_single_endpoint: default_me_adaptive_floor_min_writers_single_endpoint(),
+            me_adaptive_floor_min_writers_multi_endpoint: default_me_adaptive_floor_min_writers_multi_endpoint(),
             me_adaptive_floor_recover_grace_secs: default_me_adaptive_floor_recover_grace_secs(),
-            me_adaptive_floor_writers_per_core_total:
-                default_me_adaptive_floor_writers_per_core_total(),
+            me_adaptive_floor_writers_per_core_total: default_me_adaptive_floor_writers_per_core_total(),
             me_adaptive_floor_cpu_cores_override: default_me_adaptive_floor_cpu_cores_override(),
-            me_adaptive_floor_max_extra_writers_single_per_core:
-                default_me_adaptive_floor_max_extra_writers_single_per_core(),
-            me_adaptive_floor_max_extra_writers_multi_per_core:
-                default_me_adaptive_floor_max_extra_writers_multi_per_core(),
-            me_adaptive_floor_max_active_writers_per_core:
-                default_me_adaptive_floor_max_active_writers_per_core(),
-            me_adaptive_floor_max_warm_writers_per_core:
-                default_me_adaptive_floor_max_warm_writers_per_core(),
-            me_adaptive_floor_max_active_writers_global:
-                default_me_adaptive_floor_max_active_writers_global(),
-            me_adaptive_floor_max_warm_writers_global:
-                default_me_adaptive_floor_max_warm_writers_global(),
+            me_adaptive_floor_max_extra_writers_single_per_core: default_me_adaptive_floor_max_extra_writers_single_per_core(),
+            me_adaptive_floor_max_extra_writers_multi_per_core: default_me_adaptive_floor_max_extra_writers_multi_per_core(),
+            me_adaptive_floor_max_active_writers_per_core: default_me_adaptive_floor_max_active_writers_per_core(),
+            me_adaptive_floor_max_warm_writers_per_core: default_me_adaptive_floor_max_warm_writers_per_core(),
+            me_adaptive_floor_max_active_writers_global: default_me_adaptive_floor_max_active_writers_global(),
+            me_adaptive_floor_max_warm_writers_global: default_me_adaptive_floor_max_warm_writers_global(),
             upstream_connect_retry_attempts: default_upstream_connect_retry_attempts(),
             upstream_connect_retry_backoff_ms: default_upstream_connect_retry_backoff_ms(),
             upstream_connect_budget_ms: default_upstream_connect_budget_ms(),
-            tg_connect: default_connect_timeout(),
             upstream_unhealthy_fail_threshold: default_upstream_unhealthy_fail_threshold(),
             upstream_connect_failfast_hard_errors: default_upstream_connect_failfast_hard_errors(),
             stun_iface_mismatch_ignore: false,
@@ -1023,16 +938,13 @@ impl Default for GeneralConfig {
             me_socks_kdf_policy: MeSocksKdfPolicy::Strict,
             me_route_backpressure_base_timeout_ms: default_me_route_backpressure_base_timeout_ms(),
             me_route_backpressure_high_timeout_ms: default_me_route_backpressure_high_timeout_ms(),
-            me_route_backpressure_high_watermark_pct:
-                default_me_route_backpressure_high_watermark_pct(),
+            me_route_backpressure_high_watermark_pct: default_me_route_backpressure_high_watermark_pct(),
             me_health_interval_ms_unhealthy: default_me_health_interval_ms_unhealthy(),
             me_health_interval_ms_healthy: default_me_health_interval_ms_healthy(),
             me_admission_poll_ms: default_me_admission_poll_ms(),
             me_warn_rate_limit_ms: default_me_warn_rate_limit_ms(),
             me_route_no_writer_mode: MeRouteNoWriterMode::default(),
             me_route_no_writer_wait_ms: default_me_route_no_writer_wait_ms(),
-            me_route_hybrid_max_wait_ms: default_me_route_hybrid_max_wait_ms(),
-            me_route_blocking_send_timeout_ms: default_me_route_blocking_send_timeout_ms(),
             me_route_inline_recovery_attempts: default_me_route_inline_recovery_attempts(),
             me_route_inline_recovery_wait_ms: default_me_route_inline_recovery_wait_ms(),
             links: LinksConfig::default(),
@@ -1050,8 +962,7 @@ impl Default for GeneralConfig {
             me_hardswap_warmup_delay_min_ms: default_me_hardswap_warmup_delay_min_ms(),
             me_hardswap_warmup_delay_max_ms: default_me_hardswap_warmup_delay_max_ms(),
             me_hardswap_warmup_extra_passes: default_me_hardswap_warmup_extra_passes(),
-            me_hardswap_warmup_pass_backoff_base_ms:
-                default_me_hardswap_warmup_pass_backoff_base_ms(),
+            me_hardswap_warmup_pass_backoff_base_ms: default_me_hardswap_warmup_pass_backoff_base_ms(),
             me_config_stable_snapshots: default_me_config_stable_snapshots(),
             me_config_apply_cooldown_secs: default_me_config_apply_cooldown_secs(),
             me_snapshot_require_http_2xx: default_me_snapshot_require_http_2xx(),
@@ -1062,14 +973,6 @@ impl Default for GeneralConfig {
             me_secret_atomic_snapshot: default_me_secret_atomic_snapshot(),
             proxy_secret_len_max: default_proxy_secret_len_max(),
             me_pool_drain_ttl_secs: default_me_pool_drain_ttl_secs(),
-            me_instadrain: default_me_instadrain(),
-            me_pool_drain_threshold: default_me_pool_drain_threshold(),
-            me_pool_drain_soft_evict_enabled: default_me_pool_drain_soft_evict_enabled(),
-            me_pool_drain_soft_evict_grace_secs: default_me_pool_drain_soft_evict_grace_secs(),
-            me_pool_drain_soft_evict_per_writer: default_me_pool_drain_soft_evict_per_writer(),
-            me_pool_drain_soft_evict_budget_per_core:
-                default_me_pool_drain_soft_evict_budget_per_core(),
-            me_pool_drain_soft_evict_cooldown_ms: default_me_pool_drain_soft_evict_cooldown_ms(),
             me_bind_stale_mode: MeBindStaleMode::default(),
             me_bind_stale_ttl_secs: default_me_bind_stale_ttl_secs(),
             me_pool_min_fresh_ratio: default_me_pool_min_fresh_ratio(),
@@ -1094,10 +997,8 @@ impl GeneralConfig {
     /// Resolve the active updater interval for ME infrastructure refresh tasks.
     /// `update_every` has priority, otherwise legacy proxy_*_auto_reload_secs are used.
     pub fn effective_update_every_secs(&self) -> u64 {
-        self.update_every.unwrap_or_else(|| {
-            self.proxy_secret_auto_reload_secs
-                .min(self.proxy_config_auto_reload_secs)
-        })
+        self.update_every
+            .unwrap_or_else(|| self.proxy_secret_auto_reload_secs.min(self.proxy_config_auto_reload_secs))
     }
 
     /// Resolve periodic zero-downtime reinit interval for ME writers.
@@ -1107,14 +1008,9 @@ impl GeneralConfig {
 
     /// Resolve force-close timeout for stale writers.
     /// `me_reinit_drain_timeout_secs` remains backward-compatible alias.
-    /// A configured `0` uses the runtime safety fallback (300s).
     pub fn effective_me_pool_force_close_secs(&self) -> u64 {
-        if self.me_reinit_drain_timeout_secs == 0 {
-            300
-        } else {
         self.me_reinit_drain_timeout_secs
     }
-    }
 }
 
 /// `[general.links]` — proxy link generation settings.
@@ -1148,7 +1044,7 @@ impl Default for LinksConfig {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ApiConfig {
     /// Enable or disable REST API.
-    #[serde(default = "default_true")]
+    #[serde(default)]
     pub enabled: bool,
 
     /// Listen address for API in `IP:PORT` format.
@@ -1200,7 +1096,7 @@ pub struct ApiConfig {
 impl Default for ApiConfig {
     fn default() -> Self {
         Self {
-            enabled: default_true(),
+            enabled: false,
             listen: default_api_listen(),
             whitelist: default_api_whitelist(),
             auth_header: String::new(),
@@ -1216,118 +1112,6 @@ impl Default for ApiConfig {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum ConntrackMode {
-    #[default]
-    Tracked,
-    Notrack,
-    Hybrid,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum ConntrackBackend {
-    #[default]
-    Auto,
-    Nftables,
-    Iptables,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum ConntrackPressureProfile {
-    Conservative,
-    #[default]
-    Balanced,
-    Aggressive,
-}
-
-impl ConntrackPressureProfile {
-    pub fn client_first_byte_idle_cap_secs(self) -> u64 {
-        match self {
-            Self::Conservative => 30,
-            Self::Balanced => 20,
-            Self::Aggressive => 10,
-        }
-    }
-
-    pub fn direct_activity_timeout_secs(self) -> u64 {
-        match self {
-            Self::Conservative => 180,
-            Self::Balanced => 120,
-            Self::Aggressive => 60,
-        }
-    }
-
-    pub fn middle_soft_idle_cap_secs(self) -> u64 {
-        match self {
-            Self::Conservative => 60,
-            Self::Balanced => 30,
-            Self::Aggressive => 20,
-        }
-    }
-
-    pub fn middle_hard_idle_cap_secs(self) -> u64 {
-        match self {
-            Self::Conservative => 180,
-            Self::Balanced => 90,
-            Self::Aggressive => 60,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConntrackControlConfig {
-    /// Enables runtime conntrack-control worker for pressure mitigation.
-    #[serde(default = "default_conntrack_control_enabled")]
-    pub inline_conntrack_control: bool,
-
-    /// Conntrack mode for listener ingress traffic.
-    #[serde(default)]
-    pub mode: ConntrackMode,
-
-    /// Netfilter backend used to reconcile notrack rules.
-    #[serde(default)]
-    pub backend: ConntrackBackend,
-
-    /// Pressure profile for timeout caps under resource saturation.
-    #[serde(default)]
-    pub profile: ConntrackPressureProfile,
-
-    /// Listener IP allow-list for hybrid mode.
-    /// Ignored in tracked/notrack mode.
-    #[serde(default)]
-    pub hybrid_listener_ips: Vec<IpAddr>,
-
-    /// Pressure high watermark as percentage.
-    #[serde(default = "default_conntrack_pressure_high_watermark_pct")]
-    pub pressure_high_watermark_pct: u8,
-
-    /// Pressure low watermark as percentage.
-    #[serde(default = "default_conntrack_pressure_low_watermark_pct")]
-    pub pressure_low_watermark_pct: u8,
-
-    /// Maximum conntrack delete operations per second.
-    #[serde(default = "default_conntrack_delete_budget_per_sec")]
-    pub delete_budget_per_sec: u64,
-}
-
-impl Default for ConntrackControlConfig {
-    fn default() -> Self {
-        Self {
-            inline_conntrack_control: default_conntrack_control_enabled(),
-            mode: ConntrackMode::default(),
-            backend: ConntrackBackend::default(),
-            profile: ConntrackPressureProfile::default(),
-            hybrid_listener_ips: Vec::new(),
-            pressure_high_watermark_pct: default_conntrack_pressure_high_watermark_pct(),
-            pressure_low_watermark_pct: default_conntrack_pressure_low_watermark_pct(),
-            delete_budget_per_sec: default_conntrack_delete_budget_per_sec(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ServerConfig {
     #[serde(default = "default_port")]
@@ -1361,25 +1145,9 @@ pub struct ServerConfig {
     #[serde(default = "default_proxy_protocol_header_timeout_ms")]
     pub proxy_protocol_header_timeout_ms: u64,
 
-    /// Trusted source CIDRs allowed to send incoming PROXY protocol headers.
-    ///
-    /// If this field is omitted in config, it defaults to trust-all CIDRs
-    /// (`0.0.0.0/0` and `::/0`). If it is explicitly set to an empty list,
-    /// all PROXY protocol headers are rejected.
-    #[serde(default = "default_proxy_protocol_trusted_cidrs")]
-    pub proxy_protocol_trusted_cidrs: Vec<IpNetwork>,
-
-    /// Port for the Prometheus-compatible metrics endpoint.
-    /// Enables metrics when set; binds on all interfaces (dual-stack) by default.
     #[serde(default)]
     pub metrics_port: Option<u16>,
 
-    /// Listen address for metrics in `IP:PORT` format (e.g. `"127.0.0.1:9090"`).
-    /// When set, takes precedence over `metrics_port` and binds on the specified address only.
-    #[serde(default)]
-    pub metrics_listen: Option<String>,
-
-    /// CIDR whitelist for the metrics endpoint.
     #[serde(default = "default_metrics_whitelist")]
     pub metrics_whitelist: Vec<IpNetwork>,
 
@@ -1388,25 +1156,6 @@ pub struct ServerConfig {
 
     #[serde(default)]
     pub listeners: Vec<ListenerConfig>,
-
-    /// TCP `listen(2)` backlog for client-facing sockets (also used for the metrics HTTP listener).
-    /// The effective queue is capped by the kernel (for example `somaxconn` on Linux).
-    #[serde(default = "default_listen_backlog")]
-    pub listen_backlog: u32,
-
-    /// Maximum number of concurrent client connections.
-    /// 0 means unlimited.
-    #[serde(default = "default_server_max_connections")]
-    pub max_connections: u32,
-
-    /// Maximum wait in milliseconds while acquiring a connection slot permit.
-    /// `0` keeps legacy unbounded wait behavior.
-    #[serde(default = "default_accept_permit_timeout_ms")]
-    pub accept_permit_timeout_ms: u64,
-
-    /// Runtime conntrack control and pressure policy.
-    #[serde(default)]
-    pub conntrack_control: ConntrackControlConfig,
 }
 
 impl Default for ServerConfig {
@@ -1420,48 +1169,21 @@ impl Default for ServerConfig {
             listen_tcp: None,
             proxy_protocol: false,
             proxy_protocol_header_timeout_ms: default_proxy_protocol_header_timeout_ms(),
-            proxy_protocol_trusted_cidrs: default_proxy_protocol_trusted_cidrs(),
             metrics_port: None,
-            metrics_listen: None,
             metrics_whitelist: default_metrics_whitelist(),
             api: ApiConfig::default(),
             listeners: Vec::new(),
-            listen_backlog: default_listen_backlog(),
-            max_connections: default_server_max_connections(),
-            accept_permit_timeout_ms: default_accept_permit_timeout_ms(),
-            conntrack_control: ConntrackControlConfig::default(),
         }
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TimeoutsConfig {
-    /// Maximum idle wait in seconds for the first client byte before handshake parsing starts.
-    /// `0` disables the separate idle phase and keeps legacy timeout behavior.
-    #[serde(default = "default_client_first_byte_idle_secs")]
-    pub client_first_byte_idle_secs: u64,
-
-    /// Maximum active handshake duration in seconds after the first client byte is received.
     #[serde(default = "default_handshake_timeout")]
     pub client_handshake: u64,
 
-    /// Enables soft/hard relay client idle policy for middle-relay sessions.
-    #[serde(default = "default_relay_idle_policy_v2_enabled")]
-    pub relay_idle_policy_v2_enabled: bool,
-
-    /// Soft idle threshold for middle-relay client uplink activity in seconds.
-    /// Hitting this threshold marks the session as idle-candidate, but does not close it.
-    #[serde(default = "default_relay_client_idle_soft_secs")]
-    pub relay_client_idle_soft_secs: u64,
-
-    /// Hard idle threshold for middle-relay client uplink activity in seconds.
-    /// Hitting this threshold closes the session.
-    #[serde(default = "default_relay_client_idle_hard_secs")]
-    pub relay_client_idle_hard_secs: u64,
-
-    /// Additional grace in seconds added to hard idle window after recent downstream activity.
-    #[serde(default = "default_relay_idle_grace_after_downstream_activity_secs")]
-    pub relay_idle_grace_after_downstream_activity_secs: u64,
+    #[serde(default = "default_connect_timeout")]
+    pub tg_connect: u64,
 
     #[serde(default = "default_keepalive")]
     pub client_keepalive: u64,
@@ -1481,13 +1203,8 @@ pub struct TimeoutsConfig {
 impl Default for TimeoutsConfig {
     fn default() -> Self {
         Self {
-            client_first_byte_idle_secs: default_client_first_byte_idle_secs(),
             client_handshake: default_handshake_timeout(),
-            relay_idle_policy_v2_enabled: default_relay_idle_policy_v2_enabled(),
-            relay_client_idle_soft_secs: default_relay_client_idle_soft_secs(),
-            relay_client_idle_hard_secs: default_relay_client_idle_hard_secs(),
-            relay_idle_grace_after_downstream_activity_secs:
-                default_relay_idle_grace_after_downstream_activity_secs(),
+            tg_connect: default_connect_timeout(),
             client_keepalive: default_keepalive(),
             client_ack: default_ack_timeout(),
             me_one_retry: default_me_one_retry(),
@@ -1496,90 +1213,6 @@ impl Default for TimeoutsConfig {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum UnknownSniAction {
-    #[default]
-    Drop,
-    Mask,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum TlsFetchProfile {
-    ModernChromeLike,
-    ModernFirefoxLike,
-    CompatTls12,
-    LegacyMinimal,
-}
-
-impl TlsFetchProfile {
-    pub fn as_str(self) -> &'static str {
-        match self {
-            TlsFetchProfile::ModernChromeLike => "modern_chrome_like",
-            TlsFetchProfile::ModernFirefoxLike => "modern_firefox_like",
-            TlsFetchProfile::CompatTls12 => "compat_tls12",
-            TlsFetchProfile::LegacyMinimal => "legacy_minimal",
-        }
-    }
-}
-
-fn default_tls_fetch_profiles() -> Vec<TlsFetchProfile> {
-    vec![
-        TlsFetchProfile::ModernChromeLike,
-        TlsFetchProfile::ModernFirefoxLike,
-        TlsFetchProfile::CompatTls12,
-        TlsFetchProfile::LegacyMinimal,
-    ]
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TlsFetchConfig {
-    /// Ordered list of ClientHello profiles used for adaptive fallback.
-    #[serde(default = "default_tls_fetch_profiles")]
-    pub profiles: Vec<TlsFetchProfile>,
-
-    /// When true and upstream route is configured, TLS fetch fails closed on
-    /// upstream connect errors and does not fallback to direct TCP.
-    #[serde(default = "default_tls_fetch_strict_route")]
-    pub strict_route: bool,
-
-    /// Timeout per one profile attempt in milliseconds.
-    #[serde(default = "default_tls_fetch_attempt_timeout_ms")]
-    pub attempt_timeout_ms: u64,
-
-    /// Total wall-clock budget in milliseconds across all profile attempts.
-    #[serde(default = "default_tls_fetch_total_budget_ms")]
-    pub total_budget_ms: u64,
-
-    /// Adds GREASE-style values into selected ClientHello extensions.
-    #[serde(default)]
-    pub grease_enabled: bool,
-
-    /// Produces deterministic ClientHello randomness for debugging/tests.
-    #[serde(default)]
-    pub deterministic: bool,
-
-    /// TTL for winner-profile cache entries in seconds.
-    /// Set to 0 to disable profile cache.
-    #[serde(default = "default_tls_fetch_profile_cache_ttl_secs")]
-    pub profile_cache_ttl_secs: u64,
-}
-
-impl Default for TlsFetchConfig {
-    fn default() -> Self {
-        Self {
-            profiles: default_tls_fetch_profiles(),
-            strict_route: default_tls_fetch_strict_route(),
-            attempt_timeout_ms: default_tls_fetch_attempt_timeout_ms(),
-            total_budget_ms: default_tls_fetch_total_budget_ms(),
-            grease_enabled: false,
-            deterministic: false,
-            profile_cache_ttl_secs: default_tls_fetch_profile_cache_ttl_secs(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AntiCensorshipConfig {
     #[serde(default = "default_tls_domain")]
@@ -1589,19 +1222,6 @@ pub struct AntiCensorshipConfig {
     #[serde(default)]
     pub tls_domains: Vec<String>,
 
-    /// Policy for TLS ClientHello with unknown (non-configured) SNI.
-    #[serde(default)]
-    pub unknown_sni_action: UnknownSniAction,
-
-    /// Upstream scope used for TLS front metadata fetches.
-    /// Empty value keeps default upstream routing behavior.
-    #[serde(default = "default_tls_fetch_scope")]
-    pub tls_fetch_scope: String,
-
-    /// Fetch strategy for TLS front metadata bootstrap and periodic refresh.
-    #[serde(default)]
-    pub tls_fetch: TlsFetchConfig,
-
     #[serde(default = "default_true")]
     pub mask: bool,
 
@@ -1652,54 +1272,6 @@ pub struct AntiCensorshipConfig {
     /// Allows the backend to see the real client IP.
     #[serde(default)]
     pub mask_proxy_protocol: u8,
-
-    /// Enable shape-channel hardening on mask backend path by padding
-    /// client->mask stream tail to configured buckets on stream end.
-    #[serde(default = "default_mask_shape_hardening")]
-    pub mask_shape_hardening: bool,
-
-    /// Opt-in aggressive shape hardening mode.
-    /// When enabled, masking may shape some backend-silent timeout paths and
-    /// enforces strictly positive above-cap blur when blur is enabled.
-    #[serde(default = "default_mask_shape_hardening_aggressive_mode")]
-    pub mask_shape_hardening_aggressive_mode: bool,
-
-    /// Minimum bucket size for mask shape hardening padding.
-    #[serde(default = "default_mask_shape_bucket_floor_bytes")]
-    pub mask_shape_bucket_floor_bytes: usize,
-
-    /// Maximum bucket size for mask shape hardening padding.
-    #[serde(default = "default_mask_shape_bucket_cap_bytes")]
-    pub mask_shape_bucket_cap_bytes: usize,
-
-    /// Add bounded random tail bytes even when total bytes already exceed
-    /// mask_shape_bucket_cap_bytes.
-    #[serde(default = "default_mask_shape_above_cap_blur")]
-    pub mask_shape_above_cap_blur: bool,
-
-    /// Maximum random bytes appended above cap when above-cap blur is enabled.
-    #[serde(default = "default_mask_shape_above_cap_blur_max_bytes")]
-    pub mask_shape_above_cap_blur_max_bytes: usize,
-
-    /// Maximum bytes relayed per direction on unauthenticated masking fallback paths.
-    #[serde(default = "default_mask_relay_max_bytes")]
-    pub mask_relay_max_bytes: usize,
-
-    /// Prefetch timeout (ms) for extending fragmented masking classifier window.
-    #[serde(default = "default_mask_classifier_prefetch_timeout_ms")]
-    pub mask_classifier_prefetch_timeout_ms: u64,
-
-    /// Enable outcome-time normalization envelope for masking fallback.
-    #[serde(default = "default_mask_timing_normalization_enabled")]
-    pub mask_timing_normalization_enabled: bool,
-
-    /// Lower bound (ms) for masking outcome timing envelope.
-    #[serde(default = "default_mask_timing_normalization_floor_ms")]
-    pub mask_timing_normalization_floor_ms: u64,
-
-    /// Upper bound (ms) for masking outcome timing envelope.
-    #[serde(default = "default_mask_timing_normalization_ceiling_ms")]
-    pub mask_timing_normalization_ceiling_ms: u64,
 }
 
 impl Default for AntiCensorshipConfig {
@@ -1707,9 +1279,6 @@ impl Default for AntiCensorshipConfig {
         Self {
             tls_domain: default_tls_domain(),
             tls_domains: Vec::new(),
-            unknown_sni_action: UnknownSniAction::Drop,
-            tls_fetch_scope: default_tls_fetch_scope(),
-            tls_fetch: TlsFetchConfig::default(),
             mask: default_true(),
             mask_host: None,
             mask_port: default_mask_port(),
@@ -1723,17 +1292,6 @@ impl Default for AntiCensorshipConfig {
             tls_full_cert_ttl_secs: default_tls_full_cert_ttl_secs(),
             alpn_enforce: default_alpn_enforce(),
             mask_proxy_protocol: 0,
-            mask_shape_hardening: default_mask_shape_hardening(),
-            mask_shape_hardening_aggressive_mode: default_mask_shape_hardening_aggressive_mode(),
-            mask_shape_bucket_floor_bytes: default_mask_shape_bucket_floor_bytes(),
-            mask_shape_bucket_cap_bytes: default_mask_shape_bucket_cap_bytes(),
-            mask_shape_above_cap_blur: default_mask_shape_above_cap_blur(),
-            mask_shape_above_cap_blur_max_bytes: default_mask_shape_above_cap_blur_max_bytes(),
-            mask_relay_max_bytes: default_mask_relay_max_bytes(),
-            mask_classifier_prefetch_timeout_ms: default_mask_classifier_prefetch_timeout_ms(),
-            mask_timing_normalization_enabled: default_mask_timing_normalization_enabled(),
-            mask_timing_normalization_floor_ms: default_mask_timing_normalization_floor_ms(),
-            mask_timing_normalization_ceiling_ms: default_mask_timing_normalization_ceiling_ms(),
         }
     }
 }
@@ -1750,12 +1308,6 @@ pub struct AccessConfig {
     #[serde(default)]
     pub user_max_tcp_conns: HashMap<String, usize>,
 
-    /// Global per-user TCP connection limit applied when a user has no
-    /// positive individual override.
-    /// `0` disables the inherited limit.
-    #[serde(default = "default_user_max_tcp_conns_global_each")]
-    pub user_max_tcp_conns_global_each: usize,
-
     #[serde(default)]
     pub user_expirations: HashMap<String, DateTime<Utc>>,
 
@@ -1765,11 +1317,6 @@ pub struct AccessConfig {
     #[serde(default)]
     pub user_max_unique_ips: HashMap<String, usize>,
 
-    /// Global per-user unique IP limit applied when a user has no individual override.
-    /// `0` disables the inherited limit.
-    #[serde(default = "default_user_max_unique_ips_global_each")]
-    pub user_max_unique_ips_global_each: usize,
-
     #[serde(default)]
     pub user_max_unique_ips_mode: UserMaxUniqueIpsMode,
 
@@ -1792,11 +1339,9 @@ impl Default for AccessConfig {
             users: default_access_users(),
             user_ad_tags: HashMap::new(),
             user_max_tcp_conns: HashMap::new(),
-            user_max_tcp_conns_global_each: default_user_max_tcp_conns_global_each(),
             user_expirations: HashMap::new(),
             user_data_quota: HashMap::new(),
             user_max_unique_ips: HashMap::new(),
-            user_max_unique_ips_global_each: default_user_max_unique_ips_global_each(),
             user_max_unique_ips_mode: UserMaxUniqueIpsMode::default(),
             user_max_unique_ips_window_secs: default_user_max_unique_ips_window_secs(),
             replay_check_len: default_replay_check_len(),
@@ -1833,11 +1378,6 @@ pub enum UpstreamType {
         #[serde(default)]
         password: Option<String>,
     },
-    Shadowsocks {
-        url: String,
-        #[serde(default)]
-        interface: Option<String>,
-    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -1918,10 +1458,7 @@ impl ShowLink {
 }
 
 impl Serialize for ShowLink {
-    fn serialize<S: serde::Serializer>(
-        &self,
-        serializer: S,
-    ) -> std::result::Result<S::Ok, S::Error> {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
         match self {
             ShowLink::None => Vec::<String>::new().serialize(serializer),
             ShowLink::All => serializer.serialize_str("*"),
@@ -1931,9 +1468,7 @@ impl Serialize for ShowLink {
 }
 
 impl<'de> Deserialize<'de> for ShowLink {
-    fn deserialize<D: serde::Deserializer<'de>>(
-        deserializer: D,
-    ) -> std::result::Result<Self, D::Error> {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
         use serde::de;
 
         struct ShowLinkVisitor;
@@ -1949,14 +1484,14 @@ impl<'de> Deserialize<'de> for ShowLink {
                 if v == "*" {
                     Ok(ShowLink::All)
                 } else {
-                    Err(de::Error::invalid_value(de::Unexpected::Str(v), &r#""*""#))
+                    Err(de::Error::invalid_value(
+                        de::Unexpected::Str(v),
+                        &r#""*""#,
+                    ))
                 }
             }
 
-            fn visit_seq<A: de::SeqAccess<'de>>(
-                self,
-                mut seq: A,
-            ) -> std::result::Result<ShowLink, A::Error> {
+            fn visit_seq<A: de::SeqAccess<'de>>(self, mut seq: A) -> std::result::Result<ShowLink, A::Error> {
                 let mut names = Vec::new();
                 while let Some(name) = seq.next_element::<String>()? {
                     names.push(name);

src/conntrack_control.rs

@@ -1,755 +0,0 @@
-use std::collections::BTreeSet;
-use std::net::IpAddr;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-
-use tokio::io::AsyncWriteExt;
-use tokio::process::Command;
-use tokio::sync::{mpsc, watch};
-use tracing::{debug, info, warn};
-
-use crate::config::{ConntrackBackend, ConntrackMode, ProxyConfig};
-use crate::proxy::middle_relay::note_global_relay_pressure;
-use crate::proxy::shared_state::{ConntrackCloseEvent, ConntrackCloseReason, ProxySharedState};
-use crate::stats::Stats;
-
-const CONNTRACK_EVENT_QUEUE_CAPACITY: usize = 32_768;
-const PRESSURE_RELEASE_TICKS: u8 = 3;
-const PRESSURE_SAMPLE_INTERVAL: Duration = Duration::from_secs(1);
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum NetfilterBackend {
-    Nftables,
-    Iptables,
-}
-
-#[derive(Clone, Copy)]
-struct PressureSample {
-    conn_pct: Option<u8>,
-    fd_pct: Option<u8>,
-    accept_timeout_delta: u64,
-    me_queue_pressure_delta: u64,
-}
-
-struct PressureState {
-    active: bool,
-    low_streak: u8,
-    prev_accept_timeout_total: u64,
-    prev_me_queue_pressure_total: u64,
-}
-
-impl PressureState {
-    fn new(stats: &Stats) -> Self {
-        Self {
-            active: false,
-            low_streak: 0,
-            prev_accept_timeout_total: stats.get_accept_permit_timeout_total(),
-            prev_me_queue_pressure_total: stats.get_me_c2me_send_full_total(),
-        }
-    }
-}
-
-pub(crate) fn spawn_conntrack_controller(
-    config_rx: watch::Receiver<Arc<ProxyConfig>>,
-    stats: Arc<Stats>,
-    shared: Arc<ProxySharedState>,
-) {
-    if !cfg!(target_os = "linux") {
-        let enabled = config_rx
-            .borrow()
-            .server
-            .conntrack_control
-            .inline_conntrack_control;
-        stats.set_conntrack_control_enabled(enabled);
-        stats.set_conntrack_control_available(false);
-        stats.set_conntrack_pressure_active(false);
-        stats.set_conntrack_event_queue_depth(0);
-        stats.set_conntrack_rule_apply_ok(false);
-        shared.disable_conntrack_close_sender();
-        shared.set_conntrack_pressure_active(false);
-        if enabled {
-            warn!(
-                "conntrack control is configured but unsupported on this OS; disabling runtime worker"
-            );
-        }
-        return;
-    }
-
-    let (tx, rx) = mpsc::channel(CONNTRACK_EVENT_QUEUE_CAPACITY);
-    shared.set_conntrack_close_sender(tx);
-    tokio::spawn(async move {
-        run_conntrack_controller(config_rx, stats, shared, rx).await;
-    });
-}
-
-async fn run_conntrack_controller(
-    mut config_rx: watch::Receiver<Arc<ProxyConfig>>,
-    stats: Arc<Stats>,
-    shared: Arc<ProxySharedState>,
-    mut close_rx: mpsc::Receiver<ConntrackCloseEvent>,
-) {
-    let mut cfg = config_rx.borrow().clone();
-    let mut pressure_state = PressureState::new(stats.as_ref());
-    let mut delete_budget_tokens = cfg.server.conntrack_control.delete_budget_per_sec;
-    let mut backend = pick_backend(cfg.server.conntrack_control.backend);
-
-    apply_runtime_state(
-        stats.as_ref(),
-        shared.as_ref(),
-        &cfg,
-        backend.is_some(),
-        false,
-    );
-    reconcile_rules(&cfg, backend, stats.as_ref()).await;
-
-    loop {
-        tokio::select! {
-            changed = config_rx.changed() => {
-                if changed.is_err() {
-                    break;
-                }
-                cfg = config_rx.borrow_and_update().clone();
-                backend = pick_backend(cfg.server.conntrack_control.backend);
-                delete_budget_tokens = cfg.server.conntrack_control.delete_budget_per_sec;
-                apply_runtime_state(stats.as_ref(), shared.as_ref(), &cfg, backend.is_some(), pressure_state.active);
-                reconcile_rules(&cfg, backend, stats.as_ref()).await;
-            }
-            event = close_rx.recv() => {
-                let Some(event) = event else {
-                    break;
-                };
-                stats.set_conntrack_event_queue_depth(close_rx.len() as u64);
-                if !cfg.server.conntrack_control.inline_conntrack_control {
-                    continue;
-                }
-                if !pressure_state.active {
-                    continue;
-                }
-                if !matches!(event.reason, ConntrackCloseReason::Timeout | ConntrackCloseReason::Pressure | ConntrackCloseReason::Reset) {
-                    continue;
-                }
-                if delete_budget_tokens == 0 {
-                    continue;
-                }
-                stats.increment_conntrack_delete_attempt_total();
-                match delete_conntrack_entry(event).await {
-                    DeleteOutcome::Deleted => {
-                        delete_budget_tokens = delete_budget_tokens.saturating_sub(1);
-                        stats.increment_conntrack_delete_success_total();
-                    }
-                    DeleteOutcome::NotFound => {
-                        delete_budget_tokens = delete_budget_tokens.saturating_sub(1);
-                        stats.increment_conntrack_delete_not_found_total();
-                    }
-                    DeleteOutcome::Error => {
-                        delete_budget_tokens = delete_budget_tokens.saturating_sub(1);
-                        stats.increment_conntrack_delete_error_total();
-                    }
-                }
-            }
-            _ = tokio::time::sleep(PRESSURE_SAMPLE_INTERVAL) => {
-                delete_budget_tokens = cfg.server.conntrack_control.delete_budget_per_sec;
-                stats.set_conntrack_event_queue_depth(close_rx.len() as u64);
-                let sample = collect_pressure_sample(stats.as_ref(), &cfg, &mut pressure_state);
-                update_pressure_state(
-                    stats.as_ref(),
-                    shared.as_ref(),
-                    &cfg,
-                    &sample,
-                    &mut pressure_state,
-                );
-                if pressure_state.active {
-                    note_global_relay_pressure(shared.as_ref());
-                }
-            }
-        }
-    }
-
-    shared.disable_conntrack_close_sender();
-    shared.set_conntrack_pressure_active(false);
-    stats.set_conntrack_pressure_active(false);
-}
-
-fn apply_runtime_state(
-    stats: &Stats,
-    shared: &ProxySharedState,
-    cfg: &ProxyConfig,
-    backend_available: bool,
-    pressure_active: bool,
-) {
-    let enabled = cfg.server.conntrack_control.inline_conntrack_control;
-    let available = enabled && backend_available && has_cap_net_admin();
-    if enabled && !available {
-        warn!(
-            "conntrack control enabled but unavailable (missing CAP_NET_ADMIN or backend binaries)"
-        );
-    }
-    stats.set_conntrack_control_enabled(enabled);
-    stats.set_conntrack_control_available(available);
-    shared.set_conntrack_pressure_active(enabled && pressure_active);
-    stats.set_conntrack_pressure_active(enabled && pressure_active);
-}
-
-fn collect_pressure_sample(
-    stats: &Stats,
-    cfg: &ProxyConfig,
-    state: &mut PressureState,
-) -> PressureSample {
-    let current_connections = stats.get_current_connections_total();
-    let conn_pct = if cfg.server.max_connections == 0 {
-        None
-    } else {
-        Some(
-            ((current_connections.saturating_mul(100)) / u64::from(cfg.server.max_connections))
-                .min(100) as u8,
-        )
-    };
-
-    let fd_pct = fd_usage_pct();
-
-    let accept_total = stats.get_accept_permit_timeout_total();
-    let accept_delta = accept_total.saturating_sub(state.prev_accept_timeout_total);
-    state.prev_accept_timeout_total = accept_total;
-
-    let me_total = stats.get_me_c2me_send_full_total();
-    let me_delta = me_total.saturating_sub(state.prev_me_queue_pressure_total);
-    state.prev_me_queue_pressure_total = me_total;
-
-    PressureSample {
-        conn_pct,
-        fd_pct,
-        accept_timeout_delta: accept_delta,
-        me_queue_pressure_delta: me_delta,
-    }
-}
-
-fn update_pressure_state(
-    stats: &Stats,
-    shared: &ProxySharedState,
-    cfg: &ProxyConfig,
-    sample: &PressureSample,
-    state: &mut PressureState,
-) {
-    if !cfg.server.conntrack_control.inline_conntrack_control {
-        if state.active {
-            state.active = false;
-            state.low_streak = 0;
-            shared.set_conntrack_pressure_active(false);
-            stats.set_conntrack_pressure_active(false);
-            info!("Conntrack pressure mode deactivated (feature disabled)");
-        }
-        return;
-    }
-
-    let high = cfg.server.conntrack_control.pressure_high_watermark_pct;
-    let low = cfg.server.conntrack_control.pressure_low_watermark_pct;
-
-    let high_hit = sample.conn_pct.is_some_and(|v| v >= high)
-        || sample.fd_pct.is_some_and(|v| v >= high)
-        || sample.accept_timeout_delta > 0
-        || sample.me_queue_pressure_delta > 0;
-
-    let low_clear = sample.conn_pct.is_none_or(|v| v <= low)
-        && sample.fd_pct.is_none_or(|v| v <= low)
-        && sample.accept_timeout_delta == 0
-        && sample.me_queue_pressure_delta == 0;
-
-    if !state.active && high_hit {
-        state.active = true;
-        state.low_streak = 0;
-        shared.set_conntrack_pressure_active(true);
-        stats.set_conntrack_pressure_active(true);
-        info!(
-            conn_pct = ?sample.conn_pct,
-            fd_pct = ?sample.fd_pct,
-            accept_timeout_delta = sample.accept_timeout_delta,
-            me_queue_pressure_delta = sample.me_queue_pressure_delta,
-            "Conntrack pressure mode activated"
-        );
-        return;
-    }
-
-    if state.active && low_clear {
-        state.low_streak = state.low_streak.saturating_add(1);
-        if state.low_streak >= PRESSURE_RELEASE_TICKS {
-            state.active = false;
-            state.low_streak = 0;
-            shared.set_conntrack_pressure_active(false);
-            stats.set_conntrack_pressure_active(false);
-            info!("Conntrack pressure mode deactivated");
-        }
-        return;
-    }
-
-    state.low_streak = 0;
-}
-
-async fn reconcile_rules(cfg: &ProxyConfig, backend: Option<NetfilterBackend>, stats: &Stats) {
-    if !cfg.server.conntrack_control.inline_conntrack_control {
-        clear_notrack_rules_all_backends().await;
-        stats.set_conntrack_rule_apply_ok(true);
-        return;
-    }
-
-    if !has_cap_net_admin() {
-        stats.set_conntrack_rule_apply_ok(false);
-        return;
-    }
-
-    let Some(backend) = backend else {
-        stats.set_conntrack_rule_apply_ok(false);
-        return;
-    };
-
-    let apply_result = match backend {
-        NetfilterBackend::Nftables => apply_nft_rules(cfg).await,
-        NetfilterBackend::Iptables => apply_iptables_rules(cfg).await,
-    };
-
-    if let Err(error) = apply_result {
-        warn!(error = %error, "Failed to reconcile conntrack/notrack rules");
-        stats.set_conntrack_rule_apply_ok(false);
-    } else {
-        stats.set_conntrack_rule_apply_ok(true);
-    }
-}
-
-fn pick_backend(configured: ConntrackBackend) -> Option<NetfilterBackend> {
-    match configured {
-        ConntrackBackend::Auto => {
-            if command_exists("nft") {
-                Some(NetfilterBackend::Nftables)
-            } else if command_exists("iptables") {
-                Some(NetfilterBackend::Iptables)
-            } else {
-                None
-            }
-        }
-        ConntrackBackend::Nftables => command_exists("nft").then_some(NetfilterBackend::Nftables),
-        ConntrackBackend::Iptables => {
-            command_exists("iptables").then_some(NetfilterBackend::Iptables)
-        }
-    }
-}
-
-fn command_exists(binary: &str) -> bool {
-    let Some(path_var) = std::env::var_os("PATH") else {
-        return false;
-    };
-    std::env::split_paths(&path_var).any(|dir| {
-        let candidate: PathBuf = dir.join(binary);
-        candidate.exists() && candidate.is_file()
-    })
-}
-
-fn notrack_targets(cfg: &ProxyConfig) -> (Vec<Option<IpAddr>>, Vec<Option<IpAddr>>) {
-    let mode = cfg.server.conntrack_control.mode;
-    let mut v4_targets: BTreeSet<Option<IpAddr>> = BTreeSet::new();
-    let mut v6_targets: BTreeSet<Option<IpAddr>> = BTreeSet::new();
-
-    match mode {
-        ConntrackMode::Tracked => {}
-        ConntrackMode::Notrack => {
-            if cfg.server.listeners.is_empty() {
-                if let Some(ipv4) = cfg
-                    .server
-                    .listen_addr_ipv4
-                    .as_ref()
-                    .and_then(|s| s.parse::<IpAddr>().ok())
-                {
-                    if ipv4.is_unspecified() {
-                        v4_targets.insert(None);
-                    } else {
-                        v4_targets.insert(Some(ipv4));
-                    }
-                }
-                if let Some(ipv6) = cfg
-                    .server
-                    .listen_addr_ipv6
-                    .as_ref()
-                    .and_then(|s| s.parse::<IpAddr>().ok())
-                {
-                    if ipv6.is_unspecified() {
-                        v6_targets.insert(None);
-                    } else {
-                        v6_targets.insert(Some(ipv6));
-                    }
-                }
-            } else {
-                for listener in &cfg.server.listeners {
-                    if listener.ip.is_ipv4() {
-                        if listener.ip.is_unspecified() {
-                            v4_targets.insert(None);
-                        } else {
-                            v4_targets.insert(Some(listener.ip));
-                        }
-                    } else if listener.ip.is_unspecified() {
-                        v6_targets.insert(None);
-                    } else {
-                        v6_targets.insert(Some(listener.ip));
-                    }
-                }
-            }
-        }
-        ConntrackMode::Hybrid => {
-            for ip in &cfg.server.conntrack_control.hybrid_listener_ips {
-                if ip.is_ipv4() {
-                    v4_targets.insert(Some(*ip));
-                } else {
-                    v6_targets.insert(Some(*ip));
-                }
-            }
-        }
-    }
-
-    (
-        v4_targets.into_iter().collect(),
-        v6_targets.into_iter().collect(),
-    )
-}
-
-async fn apply_nft_rules(cfg: &ProxyConfig) -> Result<(), String> {
-    let _ = run_command(
-        "nft",
-        &["delete", "table", "inet", "telemt_conntrack"],
-        None,
-    )
-    .await;
-    if matches!(cfg.server.conntrack_control.mode, ConntrackMode::Tracked) {
-        return Ok(());
-    }
-
-    let (v4_targets, v6_targets) = notrack_targets(cfg);
-    let mut rules = Vec::new();
-    for ip in v4_targets {
-        let rule = if let Some(ip) = ip {
-            format!("tcp dport {} ip daddr {} notrack", cfg.server.port, ip)
-        } else {
-            format!("tcp dport {} notrack", cfg.server.port)
-        };
-        rules.push(rule);
-    }
-    for ip in v6_targets {
-        let rule = if let Some(ip) = ip {
-            format!("tcp dport {} ip6 daddr {} notrack", cfg.server.port, ip)
-        } else {
-            format!("tcp dport {} notrack", cfg.server.port)
-        };
-        rules.push(rule);
-    }
-
-    let rule_blob = if rules.is_empty() {
-        String::new()
-    } else {
-        format!("    {}\n", rules.join("\n    "))
-    };
-    let script = format!(
-        "table inet telemt_conntrack {{\n  chain preraw {{\n    type filter hook prerouting priority raw; policy accept;\n{rule_blob}  }}\n}}\n"
-    );
-    run_command("nft", &["-f", "-"], Some(script)).await
-}
-
-async fn apply_iptables_rules(cfg: &ProxyConfig) -> Result<(), String> {
-    apply_iptables_rules_for_binary("iptables", cfg, true).await?;
-    apply_iptables_rules_for_binary("ip6tables", cfg, false).await?;
-    Ok(())
-}
-
-async fn apply_iptables_rules_for_binary(
-    binary: &str,
-    cfg: &ProxyConfig,
-    ipv4: bool,
-) -> Result<(), String> {
-    if !command_exists(binary) {
-        return Ok(());
-    }
-    let chain = "TELEMT_NOTRACK";
-    let _ = run_command(
-        binary,
-        &["-t", "raw", "-D", "PREROUTING", "-j", chain],
-        None,
-    )
-    .await;
-    let _ = run_command(binary, &["-t", "raw", "-F", chain], None).await;
-    let _ = run_command(binary, &["-t", "raw", "-X", chain], None).await;
-
-    if matches!(cfg.server.conntrack_control.mode, ConntrackMode::Tracked) {
-        return Ok(());
-    }
-
-    run_command(binary, &["-t", "raw", "-N", chain], None).await?;
-    run_command(binary, &["-t", "raw", "-F", chain], None).await?;
-    if run_command(
-        binary,
-        &["-t", "raw", "-C", "PREROUTING", "-j", chain],
-        None,
-    )
-    .await
-    .is_err()
-    {
-        run_command(
-            binary,
-            &["-t", "raw", "-I", "PREROUTING", "1", "-j", chain],
-            None,
-        )
-        .await?;
-    }
-
-    let (v4_targets, v6_targets) = notrack_targets(cfg);
-    let selected = if ipv4 { v4_targets } else { v6_targets };
-    for ip in selected {
-        let mut args = vec![
-            "-t".to_string(),
-            "raw".to_string(),
-            "-A".to_string(),
-            chain.to_string(),
-            "-p".to_string(),
-            "tcp".to_string(),
-            "--dport".to_string(),
-            cfg.server.port.to_string(),
-        ];
-        if let Some(ip) = ip {
-            args.push("-d".to_string());
-            args.push(ip.to_string());
-        }
-        args.push("-j".to_string());
-        args.push("CT".to_string());
-        args.push("--notrack".to_string());
-        let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
-        run_command(binary, &arg_refs, None).await?;
-    }
-    Ok(())
-}
-
-async fn clear_notrack_rules_all_backends() {
-    let _ = run_command(
-        "nft",
-        &["delete", "table", "inet", "telemt_conntrack"],
-        None,
-    )
-    .await;
-    let _ = run_command(
-        "iptables",
-        &["-t", "raw", "-D", "PREROUTING", "-j", "TELEMT_NOTRACK"],
-        None,
-    )
-    .await;
-    let _ = run_command("iptables", &["-t", "raw", "-F", "TELEMT_NOTRACK"], None).await;
-    let _ = run_command("iptables", &["-t", "raw", "-X", "TELEMT_NOTRACK"], None).await;
-    let _ = run_command(
-        "ip6tables",
-        &["-t", "raw", "-D", "PREROUTING", "-j", "TELEMT_NOTRACK"],
-        None,
-    )
-    .await;
-    let _ = run_command("ip6tables", &["-t", "raw", "-F", "TELEMT_NOTRACK"], None).await;
-    let _ = run_command("ip6tables", &["-t", "raw", "-X", "TELEMT_NOTRACK"], None).await;
-}
-
-enum DeleteOutcome {
-    Deleted,
-    NotFound,
-    Error,
-}
-
-async fn delete_conntrack_entry(event: ConntrackCloseEvent) -> DeleteOutcome {
-    if !command_exists("conntrack") {
-        return DeleteOutcome::Error;
-    }
-    let args = vec![
-        "-D".to_string(),
-        "-p".to_string(),
-        "tcp".to_string(),
-        "-s".to_string(),
-        event.src.ip().to_string(),
-        "--sport".to_string(),
-        event.src.port().to_string(),
-        "-d".to_string(),
-        event.dst.ip().to_string(),
-        "--dport".to_string(),
-        event.dst.port().to_string(),
-    ];
-    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
-    match run_command("conntrack", &arg_refs, None).await {
-        Ok(()) => DeleteOutcome::Deleted,
-        Err(error) => {
-            if error.contains("0 flow entries have been deleted") {
-                DeleteOutcome::NotFound
-            } else {
-                debug!(error = %error, "conntrack delete failed");
-                DeleteOutcome::Error
-            }
-        }
-    }
-}
-
-async fn run_command(binary: &str, args: &[&str], stdin: Option<String>) -> Result<(), String> {
-    if !command_exists(binary) {
-        return Err(format!("{binary} is not available"));
-    }
-    let mut command = Command::new(binary);
-    command.args(args);
-    if stdin.is_some() {
-        command.stdin(std::process::Stdio::piped());
-    }
-    command.stdout(std::process::Stdio::null());
-    command.stderr(std::process::Stdio::piped());
-    let mut child = command
-        .spawn()
-        .map_err(|e| format!("spawn {binary} failed: {e}"))?;
-    if let Some(blob) = stdin
-        && let Some(mut writer) = child.stdin.take()
-    {
-        writer
-            .write_all(blob.as_bytes())
-            .await
-            .map_err(|e| format!("stdin write {binary} failed: {e}"))?;
-    }
-    let output = child
-        .wait_with_output()
-        .await
-        .map_err(|e| format!("wait {binary} failed: {e}"))?;
-    if output.status.success() {
-        return Ok(());
-    }
-    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-    Err(if stderr.is_empty() {
-        format!("{binary} exited with status {}", output.status)
-    } else {
-        stderr
-    })
-}
-
-fn fd_usage_pct() -> Option<u8> {
-    let soft_limit = nofile_soft_limit()?;
-    if soft_limit == 0 {
-        return None;
-    }
-    let fd_count = std::fs::read_dir("/proc/self/fd").ok()?.count() as u64;
-    Some(((fd_count.saturating_mul(100)) / soft_limit).min(100) as u8)
-}
-
-fn nofile_soft_limit() -> Option<u64> {
-    #[cfg(target_os = "linux")]
-    {
-        let mut lim = libc::rlimit {
-            rlim_cur: 0,
-            rlim_max: 0,
-        };
-        let rc = unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &mut lim) };
-        if rc != 0 {
-            return None;
-        }
-        return Some(lim.rlim_cur);
-    }
-    #[cfg(not(target_os = "linux"))]
-    {
-        None
-    }
-}
-
-fn has_cap_net_admin() -> bool {
-    #[cfg(target_os = "linux")]
-    {
-        let Ok(status) = std::fs::read_to_string("/proc/self/status") else {
-            return false;
-        };
-        for line in status.lines() {
-            if let Some(raw) = line.strip_prefix("CapEff:") {
-                let caps = raw.trim();
-                if let Ok(bits) = u64::from_str_radix(caps, 16) {
-                    const CAP_NET_ADMIN_BIT: u64 = 12;
-                    return (bits & (1u64 << CAP_NET_ADMIN_BIT)) != 0;
-                }
-            }
-        }
-        false
-    }
-    #[cfg(not(target_os = "linux"))]
-    {
-        false
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::config::ProxyConfig;
-
-    #[test]
-    fn pressure_activates_on_accept_timeout_spike() {
-        let stats = Stats::new();
-        let shared = ProxySharedState::new();
-        let mut cfg = ProxyConfig::default();
-        cfg.server.conntrack_control.inline_conntrack_control = true;
-        let mut state = PressureState::new(&stats);
-        let sample = PressureSample {
-            conn_pct: Some(10),
-            fd_pct: Some(10),
-            accept_timeout_delta: 1,
-            me_queue_pressure_delta: 0,
-        };
-
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &sample, &mut state);
-
-        assert!(state.active);
-        assert!(shared.conntrack_pressure_active());
-        assert!(stats.get_conntrack_pressure_active());
-    }
-
-    #[test]
-    fn pressure_releases_after_hysteresis_window() {
-        let stats = Stats::new();
-        let shared = ProxySharedState::new();
-        let mut cfg = ProxyConfig::default();
-        cfg.server.conntrack_control.inline_conntrack_control = true;
-        let mut state = PressureState::new(&stats);
-
-        let high_sample = PressureSample {
-            conn_pct: Some(95),
-            fd_pct: Some(95),
-            accept_timeout_delta: 0,
-            me_queue_pressure_delta: 0,
-        };
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &high_sample, &mut state);
-        assert!(state.active);
-
-        let low_sample = PressureSample {
-            conn_pct: Some(10),
-            fd_pct: Some(10),
-            accept_timeout_delta: 0,
-            me_queue_pressure_delta: 0,
-        };
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &low_sample, &mut state);
-        assert!(state.active);
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &low_sample, &mut state);
-        assert!(state.active);
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &low_sample, &mut state);
-
-        assert!(!state.active);
-        assert!(!shared.conntrack_pressure_active());
-        assert!(!stats.get_conntrack_pressure_active());
-    }
-
-    #[test]
-    fn pressure_does_not_activate_when_disabled() {
-        let stats = Stats::new();
-        let shared = ProxySharedState::new();
-        let mut cfg = ProxyConfig::default();
-        cfg.server.conntrack_control.inline_conntrack_control = false;
-        let mut state = PressureState::new(&stats);
-        let sample = PressureSample {
-            conn_pct: Some(100),
-            fd_pct: Some(100),
-            accept_timeout_delta: 10,
-            me_queue_pressure_delta: 10,
-        };
-
-        update_pressure_state(&stats, shared.as_ref(), &cfg, &sample, &mut state);
-
-        assert!(!state.active);
-        assert!(!shared.conntrack_pressure_active());
-        assert!(!stats.get_conntrack_pressure_active());
-    }
-}

src/crypto/aes.rs

@@ -13,13 +13,10 @@
 
 #![allow(dead_code)]
 
-use crate::error::{ProxyError, Result};
 use aes::Aes256;
-use ctr::{
-    Ctr128BE,
-    cipher::{KeyIvInit, StreamCipher},
-};
+use ctr::{Ctr128BE, cipher::{KeyIvInit, StreamCipher}};
 use zeroize::Zeroize;
+use crate::error::{ProxyError, Result};
 
 type Aes256Ctr = Ctr128BE<Aes256>;
 
@@ -49,16 +46,10 @@ impl AesCtr {
     /// Create from key and IV slices
     pub fn from_key_iv(key: &[u8], iv: &[u8]) -> Result<Self> {
         if key.len() != 32 {
-            return Err(ProxyError::InvalidKeyLength {
-                expected: 32,
-                got: key.len(),
-            });
+            return Err(ProxyError::InvalidKeyLength { expected: 32, got: key.len() });
         }
         if iv.len() != 16 {
-            return Err(ProxyError::InvalidKeyLength {
-                expected: 16,
-                got: iv.len(),
-            });
+            return Err(ProxyError::InvalidKeyLength { expected: 16, got: iv.len() });
         }
         
         let key: [u8; 32] = key.try_into().unwrap();
@@ -117,16 +108,10 @@ impl AesCbc {
     /// Create from slices
     pub fn from_slices(key: &[u8], iv: &[u8]) -> Result<Self> {
         if key.len() != 32 {
-            return Err(ProxyError::InvalidKeyLength {
-                expected: 32,
-                got: key.len(),
-            });
+            return Err(ProxyError::InvalidKeyLength { expected: 32, got: key.len() });
         }
         if iv.len() != 16 {
-            return Err(ProxyError::InvalidKeyLength {
-                expected: 16,
-                got: iv.len(),
-            });
+            return Err(ProxyError::InvalidKeyLength { expected: 16, got: iv.len() });
         }
         
         Ok(Self {
@@ -165,10 +150,9 @@ impl AesCbc {
     /// CBC Encryption: C[i] = AES_Encrypt(P[i] XOR C[i-1]), where C[-1] = IV
     pub fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>> {
         if !data.len().is_multiple_of(Self::BLOCK_SIZE) {
-            return Err(ProxyError::Crypto(format!(
-                "CBC data must be aligned to 16 bytes, got {}",
-                data.len()
-            )));
+            return Err(ProxyError::Crypto(
+                format!("CBC data must be aligned to 16 bytes, got {}", data.len())
+            ));
         }
         
         if data.is_empty() {
@@ -197,10 +181,9 @@ impl AesCbc {
     /// CBC Decryption: P[i] = AES_Decrypt(C[i]) XOR C[i-1], where C[-1] = IV
     pub fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>> {
         if !data.len().is_multiple_of(Self::BLOCK_SIZE) {
-            return Err(ProxyError::Crypto(format!(
-                "CBC data must be aligned to 16 bytes, got {}",
-                data.len()
-            )));
+            return Err(ProxyError::Crypto(
+                format!("CBC data must be aligned to 16 bytes, got {}", data.len())
+            ));
         }
         
         if data.is_empty() {
@@ -227,10 +210,9 @@ impl AesCbc {
     /// Encrypt data in-place
     pub fn encrypt_in_place(&self, data: &mut [u8]) -> Result<()> {
         if !data.len().is_multiple_of(Self::BLOCK_SIZE) {
-            return Err(ProxyError::Crypto(format!(
-                "CBC data must be aligned to 16 bytes, got {}",
-                data.len()
-            )));
+            return Err(ProxyError::Crypto(
+                format!("CBC data must be aligned to 16 bytes, got {}", data.len())
+            ));
         }
         
         if data.is_empty() {
@@ -261,10 +243,9 @@ impl AesCbc {
     /// Decrypt data in-place
     pub fn decrypt_in_place(&self, data: &mut [u8]) -> Result<()> {
         if !data.len().is_multiple_of(Self::BLOCK_SIZE) {
-            return Err(ProxyError::Crypto(format!(
-                "CBC data must be aligned to 16 bytes, got {}",
-                data.len()
-            )));
+            return Err(ProxyError::Crypto(
+                format!("CBC data must be aligned to 16 bytes, got {}", data.len())
+            ));
         }
         
         if data.is_empty() {

src/crypto/hash.rs

@@ -12,10 +12,10 @@
 //! usages are intentional and protocol-mandated.
 
 use hmac::{Hmac, Mac};
+use sha2::Sha256;
 use md5::Md5;
 use sha1::Sha1;
 use sha2::Digest;
-use sha2::Sha256;
 
 type HmacSha256 = Hmac<Sha256>;
 
@@ -28,7 +28,8 @@ pub fn sha256(data: &[u8]) -> [u8; 32] {
 
 /// SHA-256 HMAC
 pub fn sha256_hmac(key: &[u8], data: &[u8]) -> [u8; 32] {
-    let mut mac = HmacSha256::new_from_slice(key).expect("HMAC accepts any key length");
+    let mut mac = HmacSha256::new_from_slice(key)
+        .expect("HMAC accepts any key length");
     mac.update(data);
     mac.finalize().into_bytes().into()
 }
@@ -123,8 +124,17 @@ pub fn derive_middleproxy_keys(
     srv_ipv6: Option<&[u8; 16]>,
 ) -> ([u8; 32], [u8; 16]) {
     let s = build_middleproxy_prekey(
-        nonce_srv, nonce_clt, clt_ts, srv_ip, clt_port, purpose, clt_ip, srv_port, secret,
-        clt_ipv6, srv_ipv6,
+        nonce_srv,
+        nonce_clt,
+        clt_ts,
+        srv_ip,
+        clt_port,
+        purpose,
+        clt_ip,
+        srv_port,
+        secret,
+        clt_ipv6,
+        srv_ipv6,
     );
 
     let md5_1 = md5(&s[1..]);
@@ -154,8 +164,17 @@ mod tests {
         let secret = vec![0x55u8; 128];
 
         let prekey = build_middleproxy_prekey(
-            &nonce_srv, &nonce_clt, &clt_ts, srv_ip, &clt_port, b"CLIENT", clt_ip, &srv_port,
-            &secret, None, None,
+            &nonce_srv,
+            &nonce_clt,
+            &clt_ts,
+            srv_ip,
+            &clt_port,
+            b"CLIENT",
+            clt_ip,
+            &srv_port,
+            &secret,
+            None,
+            None,
         );
         let digest = sha256(&prekey);
         assert_eq!(

src/crypto/mod.rs

@@ -4,7 +4,7 @@ pub mod aes;
 pub mod hash;
 pub mod random;
 
-pub use aes::{AesCbc, AesCtr};
+pub use aes::{AesCtr, AesCbc};
 pub use hash::{
     build_middleproxy_prekey, crc32, crc32c, derive_middleproxy_keys, sha256, sha256_hmac,
 };

src/crypto/random.rs

@@ -3,11 +3,11 @@
 #![allow(deprecated)]
 #![allow(dead_code)]
 
-use crate::crypto::AesCtr;
-use parking_lot::Mutex;
+use rand::{Rng, RngCore, SeedableRng};
 use rand::rngs::StdRng;
-use rand::{Rng, RngExt, SeedableRng};
+use parking_lot::Mutex;
 use zeroize::Zeroize;
+use crate::crypto::AesCtr;
 
 /// Cryptographically secure PRNG with AES-CTR
 pub struct SecureRandom {
@@ -101,7 +101,7 @@ impl SecureRandom {
             return 0;
         }
         let mut inner = self.inner.lock();
-        inner.rng.random_range(0..max)
+        inner.rng.gen_range(0..max)
     }
     
     /// Generate random bits
@@ -141,7 +141,7 @@ impl SecureRandom {
     pub fn shuffle<T>(&self, slice: &mut [T]) {
         let mut inner = self.inner.lock();
         for i in (1..slice.len()).rev() {
-            let j = inner.rng.random_range(0..=i);
+            let j = inner.rng.gen_range(0..=i);
             slice.swap(i, j);
         }
     }

src/daemon/mod.rs

@@ -1,541 +0,0 @@
-//! Unix daemon support for telemt.
-//!
-//! Provides classic Unix daemonization (double-fork), PID file management,
-//! and privilege dropping for running telemt as a background service.
-
-use std::fs::{self, File, OpenOptions};
-use std::io::{self, Read, Write};
-use std::os::unix::fs::OpenOptionsExt;
-use std::path::{Path, PathBuf};
-
-use nix::fcntl::{Flock, FlockArg};
-use nix::unistd::{self, ForkResult, Gid, Pid, Uid, chdir, close, fork, getpid, setsid};
-use tracing::{debug, info, warn};
-
-/// Default PID file location.
-pub const DEFAULT_PID_FILE: &str = "/var/run/telemt.pid";
-
-/// Daemon configuration options parsed from CLI.
-#[derive(Debug, Clone, Default)]
-pub struct DaemonOptions {
-    /// Run as daemon (fork to background).
-    pub daemonize: bool,
-    /// Path to PID file.
-    pub pid_file: Option<PathBuf>,
-    /// User to run as after binding sockets.
-    pub user: Option<String>,
-    /// Group to run as after binding sockets.
-    pub group: Option<String>,
-    /// Working directory for the daemon.
-    pub working_dir: Option<PathBuf>,
-    /// Explicit foreground mode (for systemd Type=simple).
-    pub foreground: bool,
-}
-
-impl DaemonOptions {
-    /// Returns the effective PID file path.
-    pub fn pid_file_path(&self) -> &Path {
-        self.pid_file
-            .as_deref()
-            .unwrap_or(Path::new(DEFAULT_PID_FILE))
-    }
-
-    /// Returns true if we should actually daemonize.
-    /// Foreground flag takes precedence.
-    pub fn should_daemonize(&self) -> bool {
-        self.daemonize && !self.foreground
-    }
-}
-
-/// Error types for daemon operations.
-#[derive(Debug, thiserror::Error)]
-pub enum DaemonError {
-    #[error("fork failed: {0}")]
-    ForkFailed(#[source] nix::Error),
-
-    #[error("setsid failed: {0}")]
-    SetsidFailed(#[source] nix::Error),
-
-    #[error("chdir failed: {0}")]
-    ChdirFailed(#[source] nix::Error),
-
-    #[error("failed to open /dev/null: {0}")]
-    DevNullFailed(#[source] io::Error),
-
-    #[error("failed to redirect stdio: {0}")]
-    RedirectFailed(#[source] nix::Error),
-
-    #[error("PID file error: {0}")]
-    PidFile(String),
-
-    #[error("another instance is already running (pid {0})")]
-    AlreadyRunning(i32),
-
-    #[error("user '{0}' not found")]
-    UserNotFound(String),
-
-    #[error("group '{0}' not found")]
-    GroupNotFound(String),
-
-    #[error("failed to set uid/gid: {0}")]
-    PrivilegeDrop(#[source] nix::Error),
-
-    #[error("io error: {0}")]
-    Io(#[from] io::Error),
-}
-
-/// Result of a successful daemonize() call.
-#[derive(Debug)]
-pub enum DaemonizeResult {
-    /// We are the parent process and should exit.
-    Parent,
-    /// We are the daemon child process and should continue.
-    Child,
-}
-
-/// Performs classic Unix double-fork daemonization.
-///
-/// This detaches the process from the controlling terminal:
-/// 1. First fork - parent exits, child continues
-/// 2. setsid() - become session leader
-/// 3. Second fork - ensure we can never acquire a controlling terminal
-/// 4. chdir("/") - don't hold any directory open
-/// 5. Redirect stdin/stdout/stderr to /dev/null
-///
-/// Returns `DaemonizeResult::Parent` in the original parent (which should exit),
-/// or `DaemonizeResult::Child` in the final daemon child.
-pub fn daemonize(working_dir: Option<&Path>) -> Result<DaemonizeResult, DaemonError> {
-    // First fork
-    match unsafe { fork() } {
-        Ok(ForkResult::Parent { .. }) => {
-            // Parent exits
-            return Ok(DaemonizeResult::Parent);
-        }
-        Ok(ForkResult::Child) => {
-            // Child continues
-        }
-        Err(e) => return Err(DaemonError::ForkFailed(e)),
-    }
-
-    // Create new session, become session leader
-    setsid().map_err(DaemonError::SetsidFailed)?;
-
-    // Second fork to ensure we can never acquire a controlling terminal
-    match unsafe { fork() } {
-        Ok(ForkResult::Parent { .. }) => {
-            // Intermediate parent exits
-            std::process::exit(0);
-        }
-        Ok(ForkResult::Child) => {
-            // Final daemon child continues
-        }
-        Err(e) => return Err(DaemonError::ForkFailed(e)),
-    }
-
-    // Change working directory
-    let target_dir = working_dir.unwrap_or(Path::new("/"));
-    chdir(target_dir).map_err(DaemonError::ChdirFailed)?;
-
-    // Redirect stdin, stdout, stderr to /dev/null
-    redirect_stdio_to_devnull()?;
-
-    Ok(DaemonizeResult::Child)
-}
-
-/// Redirects stdin, stdout, and stderr to /dev/null.
-fn redirect_stdio_to_devnull() -> Result<(), DaemonError> {
-    let devnull = File::options()
-        .read(true)
-        .write(true)
-        .open("/dev/null")
-        .map_err(DaemonError::DevNullFailed)?;
-
-    let devnull_fd = std::os::unix::io::AsRawFd::as_raw_fd(&devnull);
-
-    // Use libc::dup2 directly for redirecting standard file descriptors
-    // nix 0.31's dup2 requires OwnedFd which doesn't work well with stdio fds
-    unsafe {
-        // Redirect stdin (fd 0)
-        if libc::dup2(devnull_fd, 0) < 0 {
-            return Err(DaemonError::RedirectFailed(nix::errno::Errno::last()));
-        }
-        // Redirect stdout (fd 1)
-        if libc::dup2(devnull_fd, 1) < 0 {
-            return Err(DaemonError::RedirectFailed(nix::errno::Errno::last()));
-        }
-        // Redirect stderr (fd 2)
-        if libc::dup2(devnull_fd, 2) < 0 {
-            return Err(DaemonError::RedirectFailed(nix::errno::Errno::last()));
-        }
-    }
-
-    // Close original devnull fd if it's not one of the standard fds
-    if devnull_fd > 2 {
-        let _ = close(devnull_fd);
-    }
-
-    Ok(())
-}
-
-/// PID file manager with flock-based locking.
-pub struct PidFile {
-    path: PathBuf,
-    file: Option<File>,
-    locked: bool,
-}
-
-impl PidFile {
-    /// Creates a new PID file manager for the given path.
-    pub fn new<P: AsRef<Path>>(path: P) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-            file: None,
-            locked: false,
-        }
-    }
-
-    /// Checks if another instance is already running.
-    ///
-    /// Returns the PID of the running instance if one exists.
-    pub fn check_running(&self) -> Result<Option<i32>, DaemonError> {
-        if !self.path.exists() {
-            return Ok(None);
-        }
-
-        // Try to read existing PID
-        let mut contents = String::new();
-        File::open(&self.path)
-            .and_then(|mut f| f.read_to_string(&mut contents))
-            .map_err(|e| {
-                DaemonError::PidFile(format!("cannot read {}: {}", self.path.display(), e))
-            })?;
-
-        let pid: i32 = contents
-            .trim()
-            .parse()
-            .map_err(|_| DaemonError::PidFile(format!("invalid PID in {}", self.path.display())))?;
-
-        // Check if process is still running
-        if is_process_running(pid) {
-            Ok(Some(pid))
-        } else {
-            // Stale PID file
-            debug!(pid, path = %self.path.display(), "Removing stale PID file");
-            let _ = fs::remove_file(&self.path);
-            Ok(None)
-        }
-    }
-
-    /// Acquires the PID file lock and writes the current PID.
-    ///
-    /// Fails if another instance is already running.
-    pub fn acquire(&mut self) -> Result<(), DaemonError> {
-        // Check for running instance first
-        if let Some(pid) = self.check_running()? {
-            return Err(DaemonError::AlreadyRunning(pid));
-        }
-
-        // Ensure parent directory exists
-        if let Some(parent) = self.path.parent() {
-            if !parent.exists() {
-                fs::create_dir_all(parent).map_err(|e| {
-                    DaemonError::PidFile(format!(
-                        "cannot create directory {}: {}",
-                        parent.display(),
-                        e
-                    ))
-                })?;
-            }
-        }
-
-        // Open/create PID file with exclusive lock
-        let file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .mode(0o644)
-            .open(&self.path)
-            .map_err(|e| {
-                DaemonError::PidFile(format!("cannot open {}: {}", self.path.display(), e))
-            })?;
-
-        // Try to acquire exclusive lock (non-blocking)
-        let flock = Flock::lock(file, FlockArg::LockExclusiveNonblock).map_err(|(_, errno)| {
-            // Check if another instance grabbed the lock
-            if let Some(pid) = self.check_running().ok().flatten() {
-                DaemonError::AlreadyRunning(pid)
-            } else {
-                DaemonError::PidFile(format!("cannot lock {}: {}", self.path.display(), errno))
-            }
-        })?;
-
-        // Write our PID
-        let pid = getpid();
-        let mut file = flock
-            .unlock()
-            .map_err(|(_, errno)| DaemonError::PidFile(format!("unlock failed: {}", errno)))?;
-
-        writeln!(file, "{}", pid).map_err(|e| {
-            DaemonError::PidFile(format!(
-                "cannot write PID to {}: {}",
-                self.path.display(),
-                e
-            ))
-        })?;
-
-        // Re-acquire lock and keep it
-        let flock = Flock::lock(file, FlockArg::LockExclusiveNonblock).map_err(|(_, errno)| {
-            DaemonError::PidFile(format!("cannot re-lock {}: {}", self.path.display(), errno))
-        })?;
-
-        self.file = Some(flock.unlock().map_err(|(_, errno)| {
-            DaemonError::PidFile(format!("unlock for storage failed: {}", errno))
-        })?);
-        self.locked = true;
-
-        info!(pid = pid.as_raw(), path = %self.path.display(), "PID file created");
-        Ok(())
-    }
-
-    /// Releases the PID file lock and removes the file.
-    pub fn release(&mut self) -> Result<(), DaemonError> {
-        if let Some(file) = self.file.take() {
-            drop(file);
-        }
-        self.locked = false;
-
-        if self.path.exists() {
-            fs::remove_file(&self.path).map_err(|e| {
-                DaemonError::PidFile(format!("cannot remove {}: {}", self.path.display(), e))
-            })?;
-            debug!(path = %self.path.display(), "PID file removed");
-        }
-
-        Ok(())
-    }
-
-    /// Returns the path to this PID file.
-    #[allow(dead_code)]
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-}
-
-impl Drop for PidFile {
-    fn drop(&mut self) {
-        if self.locked {
-            if let Err(e) = self.release() {
-                warn!(error = %e, "Failed to clean up PID file on drop");
-            }
-        }
-    }
-}
-
-/// Checks if a process with the given PID is running.
-fn is_process_running(pid: i32) -> bool {
-    // kill(pid, 0) checks if process exists without sending a signal
-    nix::sys::signal::kill(Pid::from_raw(pid), None).is_ok()
-}
-
-/// Drops privileges to the specified user and group.
-///
-/// This should be called after binding privileged ports but before
-/// entering the main event loop.
-pub fn drop_privileges(user: Option<&str>, group: Option<&str>) -> Result<(), DaemonError> {
-    // Look up group first (need to do this while still root)
-    let target_gid = if let Some(group_name) = group {
-        Some(lookup_group(group_name)?)
-    } else if let Some(user_name) = user {
-        // If no group specified but user is, use user's primary group
-        Some(lookup_user_primary_gid(user_name)?)
-    } else {
-        None
-    };
-
-    // Look up user
-    let target_uid = if let Some(user_name) = user {
-        Some(lookup_user(user_name)?)
-    } else {
-        None
-    };
-
-    // Drop privileges: set GID first, then UID
-    // (Setting UID first would prevent us from setting GID)
-    if let Some(gid) = target_gid {
-        unistd::setgid(gid).map_err(DaemonError::PrivilegeDrop)?;
-        // Also set supplementary groups to just this one
-        unistd::setgroups(&[gid]).map_err(DaemonError::PrivilegeDrop)?;
-        info!(gid = gid.as_raw(), "Dropped group privileges");
-    }
-
-    if let Some(uid) = target_uid {
-        unistd::setuid(uid).map_err(DaemonError::PrivilegeDrop)?;
-        info!(uid = uid.as_raw(), "Dropped user privileges");
-    }
-
-    Ok(())
-}
-
-/// Looks up a user by name and returns their UID.
-fn lookup_user(name: &str) -> Result<Uid, DaemonError> {
-    // Use libc getpwnam
-    let c_name =
-        std::ffi::CString::new(name).map_err(|_| DaemonError::UserNotFound(name.to_string()))?;
-
-    unsafe {
-        let pwd = libc::getpwnam(c_name.as_ptr());
-        if pwd.is_null() {
-            Err(DaemonError::UserNotFound(name.to_string()))
-        } else {
-            Ok(Uid::from_raw((*pwd).pw_uid))
-        }
-    }
-}
-
-/// Looks up a user's primary GID by username.
-fn lookup_user_primary_gid(name: &str) -> Result<Gid, DaemonError> {
-    let c_name =
-        std::ffi::CString::new(name).map_err(|_| DaemonError::UserNotFound(name.to_string()))?;
-
-    unsafe {
-        let pwd = libc::getpwnam(c_name.as_ptr());
-        if pwd.is_null() {
-            Err(DaemonError::UserNotFound(name.to_string()))
-        } else {
-            Ok(Gid::from_raw((*pwd).pw_gid))
-        }
-    }
-}
-
-/// Looks up a group by name and returns its GID.
-fn lookup_group(name: &str) -> Result<Gid, DaemonError> {
-    let c_name =
-        std::ffi::CString::new(name).map_err(|_| DaemonError::GroupNotFound(name.to_string()))?;
-
-    unsafe {
-        let grp = libc::getgrnam(c_name.as_ptr());
-        if grp.is_null() {
-            Err(DaemonError::GroupNotFound(name.to_string()))
-        } else {
-            Ok(Gid::from_raw((*grp).gr_gid))
-        }
-    }
-}
-
-/// Reads PID from a PID file.
-#[allow(dead_code)]
-pub fn read_pid_file<P: AsRef<Path>>(path: P) -> Result<i32, DaemonError> {
-    let path = path.as_ref();
-    let mut contents = String::new();
-    File::open(path)
-        .and_then(|mut f| f.read_to_string(&mut contents))
-        .map_err(|e| DaemonError::PidFile(format!("cannot read {}: {}", path.display(), e)))?;
-
-    contents
-        .trim()
-        .parse()
-        .map_err(|_| DaemonError::PidFile(format!("invalid PID in {}", path.display())))
-}
-
-/// Sends a signal to the process specified in a PID file.
-#[allow(dead_code)]
-pub fn signal_pid_file<P: AsRef<Path>>(
-    path: P,
-    signal: nix::sys::signal::Signal,
-) -> Result<(), DaemonError> {
-    let pid = read_pid_file(&path)?;
-
-    if !is_process_running(pid) {
-        return Err(DaemonError::PidFile(format!(
-            "process {} from {} is not running",
-            pid,
-            path.as_ref().display()
-        )));
-    }
-
-    nix::sys::signal::kill(Pid::from_raw(pid), signal)
-        .map_err(|e| DaemonError::PidFile(format!("cannot signal process {}: {}", pid, e)))?;
-
-    Ok(())
-}
-
-/// Returns the status of the daemon based on PID file.
-#[allow(dead_code)]
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DaemonStatus {
-    /// Daemon is running with the given PID.
-    Running(i32),
-    /// PID file exists but process is not running.
-    Stale(i32),
-    /// No PID file exists.
-    NotRunning,
-}
-
-/// Checks the daemon status from a PID file.
-#[allow(dead_code)]
-pub fn check_status<P: AsRef<Path>>(path: P) -> DaemonStatus {
-    let path = path.as_ref();
-
-    if !path.exists() {
-        return DaemonStatus::NotRunning;
-    }
-
-    match read_pid_file(path) {
-        Ok(pid) => {
-            if is_process_running(pid) {
-                DaemonStatus::Running(pid)
-            } else {
-                DaemonStatus::Stale(pid)
-            }
-        }
-        Err(_) => DaemonStatus::NotRunning,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_daemon_options_default() {
-        let opts = DaemonOptions::default();
-        assert!(!opts.daemonize);
-        assert!(!opts.should_daemonize());
-        assert_eq!(opts.pid_file_path(), Path::new(DEFAULT_PID_FILE));
-    }
-
-    #[test]
-    fn test_daemon_options_foreground_overrides() {
-        let opts = DaemonOptions {
-            daemonize: true,
-            foreground: true,
-            ..Default::default()
-        };
-        assert!(!opts.should_daemonize());
-    }
-
-    #[test]
-    fn test_check_status_not_running() {
-        let path = "/tmp/telemt_test_nonexistent.pid";
-        assert_eq!(check_status(path), DaemonStatus::NotRunning);
-    }
-
-    #[test]
-    fn test_pid_file_basic() {
-        let path = "/tmp/telemt_test_pidfile.pid";
-        let _ = fs::remove_file(path);
-
-        let mut pf = PidFile::new(path);
-        assert!(pf.check_running().unwrap().is_none());
-
-        pf.acquire().unwrap();
-        assert!(Path::new(path).exists());
-
-        // Read it back
-        let pid = read_pid_file(path).unwrap();
-        assert_eq!(pid, std::process::id() as i32);
-
-        pf.release().unwrap();
-        assert!(!Path::new(path).exists());
-    }
-}

src/error.rs

@@ -12,15 +12,28 @@ use thiserror::Error;
 #[derive(Debug)]
 pub enum StreamError {
     /// Partial read: got fewer bytes than expected
-    PartialRead { expected: usize, got: usize },
+    PartialRead {
+        expected: usize,
+        got: usize,
+    },
     /// Partial write: wrote fewer bytes than expected
-    PartialWrite { expected: usize, written: usize },
+    PartialWrite {
+        expected: usize,
+        written: usize,
+    },
     /// Stream is in poisoned state and cannot be used
-    Poisoned { reason: String },
+    Poisoned {
+        reason: String,
+    },
     /// Buffer overflow: attempted to buffer more than allowed
-    BufferOverflow { limit: usize, attempted: usize },
+    BufferOverflow {
+        limit: usize,
+        attempted: usize,
+    },
     /// Invalid frame format
-    InvalidFrame { details: String },
+    InvalidFrame {
+        details: String,
+    },
     /// Unexpected end of stream
     UnexpectedEof,
     /// Underlying I/O error
@@ -34,21 +47,13 @@ impl fmt::Display for StreamError {
                 write!(f, "partial read: expected {} bytes, got {}", expected, got)
             }
             Self::PartialWrite { expected, written } => {
-                write!(
-                    f,
-                    "partial write: expected {} bytes, wrote {}",
-                    expected, written
-                )
+                write!(f, "partial write: expected {} bytes, wrote {}", expected, written)
             }
             Self::Poisoned { reason } => {
                 write!(f, "stream poisoned: {}", reason)
             }
             Self::BufferOverflow { limit, attempted } => {
-                write!(
-                    f,
-                    "buffer overflow: limit {}, attempted {}",
-                    limit, attempted
-                )
+                write!(f, "buffer overflow: limit {}, attempted {}", limit, attempted)
             }
             Self::InvalidFrame { details } => {
                 write!(f, "invalid frame: {}", details)
@@ -85,7 +90,9 @@ impl From<StreamError> for std::io::Error {
             StreamError::UnexpectedEof => {
                 std::io::Error::new(std::io::ErrorKind::UnexpectedEof, err)
             }
-            StreamError::Poisoned { .. } => std::io::Error::other(err),
+            StreamError::Poisoned { .. } => {
+                std::io::Error::other(err)
+            }
             StreamError::BufferOverflow { .. } => {
                 std::io::Error::new(std::io::ErrorKind::OutOfMemory, err)
             }
@@ -128,10 +135,7 @@ impl Recoverable for StreamError {
     }
     
     fn can_continue(&self) -> bool {
-        !matches!(
-            self,
-            Self::Poisoned { .. } | Self::UnexpectedEof | Self::BufferOverflow { .. }
-        )
+        !matches!(self, Self::Poisoned { .. } | Self::UnexpectedEof | Self::BufferOverflow { .. })
     }
 }
 
@@ -161,6 +165,7 @@ impl Recoverable for std::io::Error {
 #[derive(Error, Debug)]
 pub enum ProxyError {
     // ============= Crypto Errors =============
+    
     #[error("Crypto error: {0}")]
     Crypto(String),
     
@@ -168,10 +173,12 @@ pub enum ProxyError {
     InvalidKeyLength { expected: usize, got: usize },
     
     // ============= Stream Errors =============
+    
     #[error("Stream error: {0}")]
     Stream(#[from] StreamError),
     
     // ============= Protocol Errors =============
+    
     #[error("Invalid handshake: {0}")]
     InvalidHandshake(String),
     
@@ -203,6 +210,7 @@ pub enum ProxyError {
     TgHandshakeTimeout,
     
     // ============= Network Errors =============
+    
     #[error("Connection timeout to {addr}")]
     ConnectionTimeout { addr: String },
     
@@ -213,16 +221,15 @@ pub enum ProxyError {
     Io(#[from] std::io::Error),
     
     // ============= Proxy Protocol Errors =============
+    
     #[error("Invalid proxy protocol header")]
     InvalidProxyProtocol,
     
-    #[error("Unknown TLS SNI")]
-    UnknownTlsSni,
-
     #[error("Proxy error: {0}")]
     Proxy(String),
     
     // ============= Config Errors =============
+    
     #[error("Config error: {0}")]
     Config(String),
     
@@ -230,6 +237,7 @@ pub enum ProxyError {
     InvalidSecret { user: String, reason: String },
     
     // ============= User Errors =============
+    
     #[error("User {user} expired")]
     UserExpired { user: String },
     
@@ -246,6 +254,7 @@ pub enum ProxyError {
     RateLimited,
     
     // ============= General Errors =============
+    
     #[error("Internal error: {0}")]
     Internal(String),
 }
@@ -302,9 +311,7 @@ impl<T, R, W> HandshakeResult<T, R, W> {
     pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> HandshakeResult<U, R, W> {
         match self {
             HandshakeResult::Success(v) => HandshakeResult::Success(f(v)),
-            HandshakeResult::BadClient { reader, writer } => {
-                HandshakeResult::BadClient { reader, writer }
-            }
+            HandshakeResult::BadClient { reader, writer } => HandshakeResult::BadClient { reader, writer },
             HandshakeResult::Error(e) => HandshakeResult::Error(e),
         }
     }
@@ -334,35 +341,18 @@ mod tests {
     
     #[test]
     fn test_stream_error_display() {
-        let err = StreamError::PartialRead {
-            expected: 100,
-            got: 50,
-        };
+        let err = StreamError::PartialRead { expected: 100, got: 50 };
         assert!(err.to_string().contains("100"));
         assert!(err.to_string().contains("50"));
         
-        let err = StreamError::Poisoned {
-            reason: "test".into(),
-        };
+        let err = StreamError::Poisoned { reason: "test".into() };
         assert!(err.to_string().contains("test"));
     }
     
     #[test]
     fn test_stream_error_recoverable() {
-        assert!(
-            StreamError::PartialRead {
-                expected: 10,
-                got: 5
-            }
-            .is_recoverable()
-        );
-        assert!(
-            StreamError::PartialWrite {
-                expected: 10,
-                written: 5
-            }
-            .is_recoverable()
-        );
+        assert!(StreamError::PartialRead { expected: 10, got: 5 }.is_recoverable());
+        assert!(StreamError::PartialWrite { expected: 10, written: 5 }.is_recoverable());
         assert!(!StreamError::Poisoned { reason: "x".into() }.is_recoverable());
         assert!(!StreamError::UnexpectedEof.is_recoverable());
     }
@@ -371,13 +361,7 @@ mod tests {
     fn test_stream_error_can_continue() {
         assert!(!StreamError::Poisoned { reason: "x".into() }.can_continue());
         assert!(!StreamError::UnexpectedEof.can_continue());
-        assert!(
-            StreamError::PartialRead {
-                expected: 10,
-                got: 5
-            }
-            .can_continue()
-        );
+        assert!(StreamError::PartialRead { expected: 10, got: 5 }.can_continue());
     }
     
     #[test]
@@ -393,10 +377,7 @@ mod tests {
         assert!(success.is_success());
         assert!(!success.is_bad_client());
         
-        let bad: HandshakeResult<i32, (), ()> = HandshakeResult::BadClient {
-            reader: (),
-            writer: (),
-        };
+        let bad: HandshakeResult<i32, (), ()> = HandshakeResult::BadClient { reader: (), writer: () };
         assert!(!bad.is_success());
         assert!(bad.is_bad_client());
     }
@@ -423,9 +404,7 @@ mod tests {
     
     #[test]
     fn test_error_display() {
-        let err = ProxyError::ConnectionTimeout {
-            addr: "1.2.3.4:443".into(),
-        };
+        let err = ProxyError::ConnectionTimeout { addr: "1.2.3.4:443".into() };
         assert!(err.to_string().contains("1.2.3.4:443"));
         
         let err = ProxyError::InvalidProxyProtocol;

src/ip_tracker.rs

@@ -5,11 +5,10 @@
 use std::collections::HashMap;
 use std::net::IpAddr;
 use std::sync::Arc;
-use std::sync::Mutex;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 
-use tokio::sync::{Mutex as AsyncMutex, RwLock};
+use tokio::sync::RwLock;
 
 use crate::config::UserMaxUniqueIpsMode;
 
@@ -18,21 +17,9 @@ pub struct UserIpTracker {
     active_ips: Arc<RwLock<HashMap<String, HashMap<IpAddr, usize>>>>,
     recent_ips: Arc<RwLock<HashMap<String, HashMap<IpAddr, Instant>>>>,
     max_ips: Arc<RwLock<HashMap<String, usize>>>,
-    default_max_ips: Arc<RwLock<usize>>,
     limit_mode: Arc<RwLock<UserMaxUniqueIpsMode>>,
     limit_window: Arc<RwLock<Duration>>,
     last_compact_epoch_secs: Arc<AtomicU64>,
-    cleanup_queue: Arc<Mutex<Vec<(String, IpAddr)>>>,
-    cleanup_drain_lock: Arc<AsyncMutex<()>>,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct UserIpTrackerMemoryStats {
-    pub active_users: usize,
-    pub recent_users: usize,
-    pub active_entries: usize,
-    pub recent_entries: usize,
-    pub cleanup_queue_len: usize,
 }
 
 impl UserIpTracker {
@@ -41,83 +28,9 @@ impl UserIpTracker {
             active_ips: Arc::new(RwLock::new(HashMap::new())),
             recent_ips: Arc::new(RwLock::new(HashMap::new())),
             max_ips: Arc::new(RwLock::new(HashMap::new())),
-            default_max_ips: Arc::new(RwLock::new(0)),
             limit_mode: Arc::new(RwLock::new(UserMaxUniqueIpsMode::ActiveWindow)),
             limit_window: Arc::new(RwLock::new(Duration::from_secs(30))),
             last_compact_epoch_secs: Arc::new(AtomicU64::new(0)),
-            cleanup_queue: Arc::new(Mutex::new(Vec::new())),
-            cleanup_drain_lock: Arc::new(AsyncMutex::new(())),
-        }
-    }
-
-    pub fn enqueue_cleanup(&self, user: String, ip: IpAddr) {
-        match self.cleanup_queue.lock() {
-            Ok(mut queue) => queue.push((user, ip)),
-            Err(poisoned) => {
-                let mut queue = poisoned.into_inner();
-                queue.push((user.clone(), ip));
-                self.cleanup_queue.clear_poison();
-                tracing::warn!(
-                    "UserIpTracker cleanup_queue lock poisoned; recovered and enqueued IP cleanup for {} ({})",
-                    user,
-                    ip
-                );
-            }
-        }
-    }
-
-    #[cfg(test)]
-    pub(crate) fn cleanup_queue_len_for_tests(&self) -> usize {
-        self.cleanup_queue
-            .lock()
-            .unwrap_or_else(|poisoned| poisoned.into_inner())
-            .len()
-    }
-
-    #[cfg(test)]
-    pub(crate) fn cleanup_queue_mutex_for_tests(&self) -> Arc<Mutex<Vec<(String, IpAddr)>>> {
-        Arc::clone(&self.cleanup_queue)
-    }
-
-    pub(crate) async fn drain_cleanup_queue(&self) {
-        // Serialize queue draining and active-IP mutation so check-and-add cannot
-        // observe stale active entries that are already queued for removal.
-        let _drain_guard = self.cleanup_drain_lock.lock().await;
-        let to_remove = {
-            match self.cleanup_queue.lock() {
-                Ok(mut queue) => {
-                    if queue.is_empty() {
-                        return;
-                    }
-                    std::mem::take(&mut *queue)
-                }
-                Err(poisoned) => {
-                    let mut queue = poisoned.into_inner();
-                    if queue.is_empty() {
-                        self.cleanup_queue.clear_poison();
-                        return;
-                    }
-                    let drained = std::mem::take(&mut *queue);
-                    self.cleanup_queue.clear_poison();
-                    drained
-                }
-            }
-        };
-
-        let mut active_ips = self.active_ips.write().await;
-        for (user, ip) in to_remove {
-            if let Some(user_ips) = active_ips.get_mut(&user) {
-                if let Some(count) = user_ips.get_mut(&ip) {
-                    if *count > 1 {
-                        *count -= 1;
-                    } else {
-                        user_ips.remove(&ip);
-                    }
-                }
-                if user_ips.is_empty() {
-                    active_ips.remove(&user);
-                }
-            }
         }
     }
 
@@ -150,15 +63,7 @@ impl UserIpTracker {
 
         let mut active_ips = self.active_ips.write().await;
         let mut recent_ips = self.recent_ips.write().await;
-        let window = *self.limit_window.read().await;
-        let now = Instant::now();
-
-        for user_recent in recent_ips.values_mut() {
-            Self::prune_recent(user_recent, now, window);
-        }
-
-        let mut users =
-            Vec::<String>::with_capacity(active_ips.len().saturating_add(recent_ips.len()));
+        let mut users = Vec::<String>::with_capacity(active_ips.len().saturating_add(recent_ips.len()));
         users.extend(active_ips.keys().cloned());
         for user in recent_ips.keys() {
             if !active_ips.contains_key(user) {
@@ -167,14 +72,8 @@ impl UserIpTracker {
         }
 
         for user in users {
-            let active_empty = active_ips
-                .get(&user)
-                .map(|ips| ips.is_empty())
-                .unwrap_or(true);
-            let recent_empty = recent_ips
-                .get(&user)
-                .map(|ips| ips.is_empty())
-                .unwrap_or(true);
+            let active_empty = active_ips.get(&user).map(|ips| ips.is_empty()).unwrap_or(true);
+            let recent_empty = recent_ips.get(&user).map(|ips| ips.is_empty()).unwrap_or(true);
             if active_empty && recent_empty {
                 active_ips.remove(&user);
                 recent_ips.remove(&user);
@@ -182,26 +81,6 @@ impl UserIpTracker {
         }
     }
 
-    pub async fn memory_stats(&self) -> UserIpTrackerMemoryStats {
-        let cleanup_queue_len = self
-            .cleanup_queue
-            .lock()
-            .unwrap_or_else(|poisoned| poisoned.into_inner())
-            .len();
-        let active_ips = self.active_ips.read().await;
-        let recent_ips = self.recent_ips.read().await;
-        let active_entries = active_ips.values().map(HashMap::len).sum();
-        let recent_entries = recent_ips.values().map(HashMap::len).sum();
-
-        UserIpTrackerMemoryStats {
-            active_users: active_ips.len(),
-            recent_users: recent_ips.len(),
-            active_entries,
-            recent_entries,
-            cleanup_queue_len,
-        }
-    }
-
     pub async fn set_limit_policy(&self, mode: UserMaxUniqueIpsMode, window_secs: u64) {
         {
             let mut current_mode = self.limit_mode.write().await;
@@ -221,10 +100,7 @@ impl UserIpTracker {
         limits.remove(username);
     }
 
-    pub async fn load_limits(&self, default_limit: usize, limits: &HashMap<String, usize>) {
-        let mut default_max_ips = self.default_max_ips.write().await;
-        *default_max_ips = default_limit;
-        drop(default_max_ips);
+    pub async fn load_limits(&self, limits: &HashMap<String, usize>) {
         let mut max_ips = self.max_ips.write().await;
         max_ips.clone_from(limits);
     }
@@ -237,16 +113,10 @@ impl UserIpTracker {
     }
 
     pub async fn check_and_add(&self, username: &str, ip: IpAddr) -> Result<(), String> {
-        self.drain_cleanup_queue().await;
         self.maybe_compact_empty_users().await;
-        let default_max_ips = *self.default_max_ips.read().await;
         let limit = {
             let max_ips = self.max_ips.read().await;
-            max_ips
-                .get(username)
-                .copied()
-                .filter(|limit| *limit > 0)
-                .or((default_max_ips > 0).then_some(default_max_ips))
+            max_ips.get(username).copied()
         };
         let mode = *self.limit_mode.read().await;
         let window = *self.limit_window.read().await;
@@ -314,7 +184,6 @@ impl UserIpTracker {
     }
 
     pub async fn get_recent_counts_for_users(&self, users: &[String]) -> HashMap<String, usize> {
-        self.drain_cleanup_queue().await;
         let window = *self.limit_window.read().await;
         let now = Instant::now();
         let recent_ips = self.recent_ips.read().await;
@@ -335,7 +204,6 @@ impl UserIpTracker {
     }
 
     pub async fn get_active_ips_for_users(&self, users: &[String]) -> HashMap<String, Vec<IpAddr>> {
-        self.drain_cleanup_queue().await;
         let active_ips = self.active_ips.read().await;
         let mut out = HashMap::with_capacity(users.len());
         for user in users {
@@ -350,7 +218,6 @@ impl UserIpTracker {
     }
 
     pub async fn get_recent_ips_for_users(&self, users: &[String]) -> HashMap<String, Vec<IpAddr>> {
-        self.drain_cleanup_queue().await;
         let window = *self.limit_window.read().await;
         let now = Instant::now();
         let recent_ips = self.recent_ips.read().await;
@@ -373,13 +240,11 @@ impl UserIpTracker {
     }
 
     pub async fn get_active_ip_count(&self, username: &str) -> usize {
-        self.drain_cleanup_queue().await;
         let active_ips = self.active_ips.read().await;
         active_ips.get(username).map(|ips| ips.len()).unwrap_or(0)
     }
 
     pub async fn get_active_ips(&self, username: &str) -> Vec<IpAddr> {
-        self.drain_cleanup_queue().await;
         let active_ips = self.active_ips.read().await;
         active_ips
             .get(username)
@@ -388,19 +253,12 @@ impl UserIpTracker {
     }
 
     pub async fn get_stats(&self) -> Vec<(String, usize, usize)> {
-        self.drain_cleanup_queue().await;
         let active_ips = self.active_ips.read().await;
         let max_ips = self.max_ips.read().await;
-        let default_max_ips = *self.default_max_ips.read().await;
 
         let mut stats = Vec::new();
         for (username, user_ips) in active_ips.iter() {
-            let limit = max_ips
-                .get(username)
-                .copied()
-                .filter(|limit| *limit > 0)
-                .or((default_max_ips > 0).then_some(default_max_ips))
-                .unwrap_or(0);
+            let limit = max_ips.get(username).copied().unwrap_or(0);
             stats.push((username.clone(), user_ips.len(), limit));
         }
 
@@ -427,7 +285,6 @@ impl UserIpTracker {
     }
 
     pub async fn is_ip_active(&self, username: &str, ip: IpAddr) -> bool {
-        self.drain_cleanup_queue().await;
         let active_ips = self.active_ips.read().await;
         active_ips
             .get(username)
@@ -436,13 +293,8 @@ impl UserIpTracker {
     }
 
     pub async fn get_user_limit(&self, username: &str) -> Option<usize> {
-        let default_max_ips = *self.default_max_ips.read().await;
         let max_ips = self.max_ips.read().await;
-        max_ips
-            .get(username)
-            .copied()
-            .filter(|limit| *limit > 0)
-            .or((default_max_ips > 0).then_some(default_max_ips))
+        max_ips.get(username).copied()
     }
 
     pub async fn format_stats(&self) -> String {
@@ -487,7 +339,6 @@ impl Default for UserIpTracker {
 mod tests {
     use super::*;
     use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    use std::sync::atomic::Ordering;
 
     fn test_ipv4(oct1: u8, oct2: u8, oct3: u8, oct4: u8) -> IpAddr {
         IpAddr::V4(Ipv4Addr::new(oct1, oct2, oct3, oct4))
@@ -695,7 +546,7 @@ mod tests {
         config_limits.insert("user1".to_string(), 5);
         config_limits.insert("user2".to_string(), 3);
 
-        tracker.load_limits(0, &config_limits).await;
+        tracker.load_limits(&config_limits).await;
 
         assert_eq!(tracker.get_user_limit("user1").await, Some(5));
         assert_eq!(tracker.get_user_limit("user2").await, Some(3));
@@ -709,46 +560,16 @@ mod tests {
         let mut first = HashMap::new();
         first.insert("user1".to_string(), 2);
         first.insert("user2".to_string(), 3);
-        tracker.load_limits(0, &first).await;
+        tracker.load_limits(&first).await;
 
         let mut second = HashMap::new();
         second.insert("user2".to_string(), 5);
-        tracker.load_limits(0, &second).await;
+        tracker.load_limits(&second).await;
 
         assert_eq!(tracker.get_user_limit("user1").await, None);
         assert_eq!(tracker.get_user_limit("user2").await, Some(5));
     }
 
-    #[tokio::test]
-    async fn test_global_each_limit_applies_without_user_override() {
-        let tracker = UserIpTracker::new();
-        tracker.load_limits(2, &HashMap::new()).await;
-
-        let ip1 = test_ipv4(172, 16, 0, 1);
-        let ip2 = test_ipv4(172, 16, 0, 2);
-        let ip3 = test_ipv4(172, 16, 0, 3);
-
-        assert!(tracker.check_and_add("test_user", ip1).await.is_ok());
-        assert!(tracker.check_and_add("test_user", ip2).await.is_ok());
-        assert!(tracker.check_and_add("test_user", ip3).await.is_err());
-        assert_eq!(tracker.get_user_limit("test_user").await, Some(2));
-    }
-
-    #[tokio::test]
-    async fn test_user_override_wins_over_global_each_limit() {
-        let tracker = UserIpTracker::new();
-        let mut limits = HashMap::new();
-        limits.insert("test_user".to_string(), 1);
-        tracker.load_limits(3, &limits).await;
-
-        let ip1 = test_ipv4(172, 17, 0, 1);
-        let ip2 = test_ipv4(172, 17, 0, 2);
-
-        assert!(tracker.check_and_add("test_user", ip1).await.is_ok());
-        assert!(tracker.check_and_add("test_user", ip2).await.is_err());
-        assert_eq!(tracker.get_user_limit("test_user").await, Some(1));
-    }
-
     #[tokio::test]
     async fn test_time_window_mode_blocks_recent_ip_churn() {
         let tracker = UserIpTracker::new();
@@ -801,54 +622,4 @@ mod tests {
         tokio::time::sleep(Duration::from_millis(1100)).await;
         assert!(tracker.check_and_add("test_user", ip2).await.is_ok());
     }
-
-    #[tokio::test]
-    async fn test_memory_stats_reports_queue_and_entry_counts() {
-        let tracker = UserIpTracker::new();
-        tracker.set_user_limit("test_user", 4).await;
-        let ip1 = test_ipv4(10, 2, 0, 1);
-        let ip2 = test_ipv4(10, 2, 0, 2);
-
-        tracker.check_and_add("test_user", ip1).await.unwrap();
-        tracker.check_and_add("test_user", ip2).await.unwrap();
-        tracker.enqueue_cleanup("test_user".to_string(), ip1);
-
-        let snapshot = tracker.memory_stats().await;
-        assert_eq!(snapshot.active_users, 1);
-        assert_eq!(snapshot.recent_users, 1);
-        assert_eq!(snapshot.active_entries, 2);
-        assert_eq!(snapshot.recent_entries, 2);
-        assert_eq!(snapshot.cleanup_queue_len, 1);
-    }
-
-    #[tokio::test]
-    async fn test_compact_prunes_stale_recent_entries() {
-        let tracker = UserIpTracker::new();
-        tracker
-            .set_limit_policy(UserMaxUniqueIpsMode::TimeWindow, 1)
-            .await;
-
-        let stale_user = "stale-user".to_string();
-        let stale_ip = test_ipv4(10, 3, 0, 1);
-        {
-            let mut recent_ips = tracker.recent_ips.write().await;
-            recent_ips
-                .entry(stale_user.clone())
-                .or_insert_with(HashMap::new)
-                .insert(stale_ip, Instant::now() - Duration::from_secs(5));
-        }
-
-        tracker.last_compact_epoch_secs.store(0, Ordering::Relaxed);
-        tracker
-            .check_and_add("trigger-user", test_ipv4(10, 3, 0, 2))
-            .await
-            .unwrap();
-
-        let recent_ips = tracker.recent_ips.read().await;
-        let stale_exists = recent_ips
-            .get(&stale_user)
-            .map(|ips| ips.contains_key(&stale_ip))
-            .unwrap_or(false);
-        assert!(!stale_exists);
-    }
 }

src/logging.rs

@@ -1,343 +0,0 @@
-//! Logging configuration for telemt.
-//!
-//! Supports multiple log destinations:
-//! - stderr (default, works with systemd journald)
-//! - syslog (Unix only, for traditional init systems)
-//! - file (with optional rotation)
-
-#![allow(dead_code)] // Infrastructure module - used via CLI flags
-
-use std::path::Path;
-
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::util::SubscriberInitExt;
-use tracing_subscriber::{EnvFilter, fmt, reload};
-
-/// Log destination configuration.
-#[derive(Debug, Clone, Default)]
-pub enum LogDestination {
-    /// Log to stderr (default, captured by systemd journald).
-    #[default]
-    Stderr,
-    /// Log to syslog (Unix only).
-    #[cfg(unix)]
-    Syslog,
-    /// Log to a file with optional rotation.
-    File {
-        path: String,
-        /// Rotate daily if true.
-        rotate_daily: bool,
-    },
-}
-
-/// Logging options parsed from CLI/config.
-#[derive(Debug, Clone, Default)]
-pub struct LoggingOptions {
-    /// Where to send logs.
-    pub destination: LogDestination,
-    /// Disable ANSI colors.
-    pub disable_colors: bool,
-}
-
-/// Guard that must be held to keep file logging active.
-/// When dropped, flushes and closes log files.
-pub struct LoggingGuard {
-    _guard: Option<tracing_appender::non_blocking::WorkerGuard>,
-}
-
-impl LoggingGuard {
-    fn new(guard: Option<tracing_appender::non_blocking::WorkerGuard>) -> Self {
-        Self { _guard: guard }
-    }
-
-    /// Creates a no-op guard for stderr/syslog logging.
-    pub fn noop() -> Self {
-        Self { _guard: None }
-    }
-}
-
-/// Initialize the tracing subscriber with the specified options.
-///
-/// Returns a reload handle for dynamic log level changes and a guard
-/// that must be kept alive for file logging.
-pub fn init_logging(
-    opts: &LoggingOptions,
-    initial_filter: &str,
-) -> (
-    reload::Handle<EnvFilter, impl tracing::Subscriber + Send + Sync>,
-    LoggingGuard,
-) {
-    let (filter_layer, filter_handle) = reload::Layer::new(EnvFilter::new(initial_filter));
-
-    match &opts.destination {
-        LogDestination::Stderr => {
-            let fmt_layer = fmt::Layer::default()
-                .with_ansi(!opts.disable_colors)
-                .with_target(true);
-
-            tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer)
-                .init();
-
-            (filter_handle, LoggingGuard::noop())
-        }
-
-        #[cfg(unix)]
-        LogDestination::Syslog => {
-            // Use a custom fmt layer that writes to syslog
-            let fmt_layer = fmt::Layer::default()
-                .with_ansi(false)
-                .with_target(false)
-                .with_level(false)
-                .without_time()
-                .with_writer(SyslogMakeWriter::new());
-
-            tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer)
-                .init();
-
-            (filter_handle, LoggingGuard::noop())
-        }
-
-        LogDestination::File { path, rotate_daily } => {
-            let (non_blocking, guard) = if *rotate_daily {
-                // Extract directory and filename prefix
-                let path = Path::new(path);
-                let dir = path.parent().unwrap_or(Path::new("/var/log"));
-                let prefix = path
-                    .file_name()
-                    .and_then(|s| s.to_str())
-                    .unwrap_or("telemt");
-
-                let file_appender = tracing_appender::rolling::daily(dir, prefix);
-                tracing_appender::non_blocking(file_appender)
-            } else {
-                let file = std::fs::OpenOptions::new()
-                    .create(true)
-                    .append(true)
-                    .open(path)
-                    .expect("Failed to open log file");
-                tracing_appender::non_blocking(file)
-            };
-
-            let fmt_layer = fmt::Layer::default()
-                .with_ansi(false)
-                .with_target(true)
-                .with_writer(non_blocking);
-
-            tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer)
-                .init();
-
-            (filter_handle, LoggingGuard::new(Some(guard)))
-        }
-    }
-}
-
-/// Syslog writer for tracing.
-#[cfg(unix)]
-#[derive(Clone, Copy)]
-struct SyslogMakeWriter;
-
-#[cfg(unix)]
-#[derive(Clone, Copy)]
-struct SyslogWriter {
-    priority: libc::c_int,
-}
-
-#[cfg(unix)]
-impl SyslogMakeWriter {
-    fn new() -> Self {
-        // Open syslog connection on first use
-        static INIT: std::sync::Once = std::sync::Once::new();
-        INIT.call_once(|| {
-            unsafe {
-                // Open syslog with ident "telemt", LOG_PID, LOG_DAEMON facility
-                let ident = b"telemt\0".as_ptr() as *const libc::c_char;
-                libc::openlog(ident, libc::LOG_PID | libc::LOG_NDELAY, libc::LOG_DAEMON);
-            }
-        });
-        Self
-    }
-}
-
-#[cfg(unix)]
-fn syslog_priority_for_level(level: &tracing::Level) -> libc::c_int {
-    match *level {
-        tracing::Level::ERROR => libc::LOG_ERR,
-        tracing::Level::WARN => libc::LOG_WARNING,
-        tracing::Level::INFO => libc::LOG_INFO,
-        tracing::Level::DEBUG => libc::LOG_DEBUG,
-        tracing::Level::TRACE => libc::LOG_DEBUG,
-    }
-}
-
-#[cfg(unix)]
-impl std::io::Write for SyslogWriter {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        // Convert to C string, stripping newlines
-        let msg = String::from_utf8_lossy(buf);
-        let msg = msg.trim_end();
-
-        if msg.is_empty() {
-            return Ok(buf.len());
-        }
-
-        // Write to syslog
-        let c_msg = std::ffi::CString::new(msg.as_bytes())
-            .unwrap_or_else(|_| std::ffi::CString::new("(invalid utf8)").unwrap());
-
-        unsafe {
-            libc::syslog(
-                self.priority,
-                b"%s\0".as_ptr() as *const libc::c_char,
-                c_msg.as_ptr(),
-            );
-        }
-
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-#[cfg(unix)]
-impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for SyslogMakeWriter {
-    type Writer = SyslogWriter;
-
-    fn make_writer(&'a self) -> Self::Writer {
-        SyslogWriter {
-            priority: libc::LOG_INFO,
-        }
-    }
-
-    fn make_writer_for(&'a self, meta: &tracing::Metadata<'_>) -> Self::Writer {
-        SyslogWriter {
-            priority: syslog_priority_for_level(meta.level()),
-        }
-    }
-}
-
-/// Parse log destination from CLI arguments.
-pub fn parse_log_destination(args: &[String]) -> LogDestination {
-    let mut i = 0;
-    while i < args.len() {
-        match args[i].as_str() {
-            #[cfg(unix)]
-            "--syslog" => {
-                return LogDestination::Syslog;
-            }
-            "--log-file" => {
-                i += 1;
-                if i < args.len() {
-                    return LogDestination::File {
-                        path: args[i].clone(),
-                        rotate_daily: false,
-                    };
-                }
-            }
-            s if s.starts_with("--log-file=") => {
-                return LogDestination::File {
-                    path: s.trim_start_matches("--log-file=").to_string(),
-                    rotate_daily: false,
-                };
-            }
-            "--log-file-daily" => {
-                i += 1;
-                if i < args.len() {
-                    return LogDestination::File {
-                        path: args[i].clone(),
-                        rotate_daily: true,
-                    };
-                }
-            }
-            s if s.starts_with("--log-file-daily=") => {
-                return LogDestination::File {
-                    path: s.trim_start_matches("--log-file-daily=").to_string(),
-                    rotate_daily: true,
-                };
-            }
-            _ => {}
-        }
-        i += 1;
-    }
-    LogDestination::Stderr
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_log_destination_default() {
-        let args: Vec<String> = vec![];
-        assert!(matches!(
-            parse_log_destination(&args),
-            LogDestination::Stderr
-        ));
-    }
-
-    #[test]
-    fn test_parse_log_destination_file() {
-        let args = vec!["--log-file".to_string(), "/var/log/telemt.log".to_string()];
-        match parse_log_destination(&args) {
-            LogDestination::File { path, rotate_daily } => {
-                assert_eq!(path, "/var/log/telemt.log");
-                assert!(!rotate_daily);
-            }
-            _ => panic!("Expected File destination"),
-        }
-    }
-
-    #[test]
-    fn test_parse_log_destination_file_daily() {
-        let args = vec!["--log-file-daily=/var/log/telemt".to_string()];
-        match parse_log_destination(&args) {
-            LogDestination::File { path, rotate_daily } => {
-                assert_eq!(path, "/var/log/telemt");
-                assert!(rotate_daily);
-            }
-            _ => panic!("Expected File destination"),
-        }
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn test_parse_log_destination_syslog() {
-        let args = vec!["--syslog".to_string()];
-        assert!(matches!(
-            parse_log_destination(&args),
-            LogDestination::Syslog
-        ));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn test_syslog_priority_for_level_mapping() {
-        assert_eq!(
-            syslog_priority_for_level(&tracing::Level::ERROR),
-            libc::LOG_ERR
-        );
-        assert_eq!(
-            syslog_priority_for_level(&tracing::Level::WARN),
-            libc::LOG_WARNING
-        );
-        assert_eq!(
-            syslog_priority_for_level(&tracing::Level::INFO),
-            libc::LOG_INFO
-        );
-        assert_eq!(
-            syslog_priority_for_level(&tracing::Level::DEBUG),
-            libc::LOG_DEBUG
-        );
-        assert_eq!(
-            syslog_priority_for_level(&tracing::Level::TRACE),
-            libc::LOG_DEBUG
-        );
-    }
-}

src/maestro/admission.rs

@@ -1,170 +0,0 @@
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-use tokio::sync::watch;
-use tracing::{info, warn};
-
-use crate::config::ProxyConfig;
-use crate::proxy::route_mode::{RelayRouteMode, RouteRuntimeController};
-use crate::transport::middle_proxy::MePool;
-
-const STARTUP_FALLBACK_AFTER: Duration = Duration::from_secs(80);
-const RUNTIME_FALLBACK_AFTER: Duration = Duration::from_secs(6);
-
-pub(crate) async fn configure_admission_gate(
-    config: &Arc<ProxyConfig>,
-    me_pool: Option<Arc<MePool>>,
-    route_runtime: Arc<RouteRuntimeController>,
-    admission_tx: &watch::Sender<bool>,
-    config_rx: watch::Receiver<Arc<ProxyConfig>>,
-) {
-    if config.general.use_middle_proxy {
-        if let Some(pool) = me_pool.as_ref() {
-            let initial_ready = pool.admission_ready_conditional_cast().await;
-            let mut fallback_enabled = config.general.me2dc_fallback;
-            let mut fast_fallback_enabled = fallback_enabled && config.general.me2dc_fast;
-            let (initial_gate_open, initial_route_mode, initial_fallback_reason) = if initial_ready
-            {
-                (true, RelayRouteMode::Middle, None)
-            } else if fast_fallback_enabled {
-                (
-                    true,
-                    RelayRouteMode::Direct,
-                    Some("fast_not_ready_fallback"),
-                )
-            } else {
-                (false, RelayRouteMode::Middle, None)
-            };
-            admission_tx.send_replace(initial_gate_open);
-            let _ = route_runtime.set_mode(initial_route_mode);
-            if initial_ready {
-                info!("Conditional-admission gate: open / ME pool READY");
-            } else if let Some(reason) = initial_fallback_reason {
-                warn!(
-                    fallback_reason = reason,
-                    "Conditional-admission gate opened in ME fast fallback mode"
-                );
-            } else {
-                warn!("Conditional-admission gate: closed / ME pool is NOT ready)");
-            }
-
-            let pool_for_gate = pool.clone();
-            let admission_tx_gate = admission_tx.clone();
-            let route_runtime_gate = route_runtime.clone();
-            let mut config_rx_gate = config_rx.clone();
-            let mut admission_poll_ms = config.general.me_admission_poll_ms.max(1);
-            tokio::spawn(async move {
-                let mut gate_open = initial_gate_open;
-                let mut route_mode = initial_route_mode;
-                let mut ready_observed = initial_ready;
-                let mut not_ready_since = if initial_ready {
-                    None
-                } else {
-                    Some(Instant::now())
-                };
-                loop {
-                    tokio::select! {
-                        changed = config_rx_gate.changed() => {
-                            if changed.is_err() {
-                                break;
-                            }
-                            let cfg = config_rx_gate.borrow_and_update().clone();
-                            admission_poll_ms = cfg.general.me_admission_poll_ms.max(1);
-                            fallback_enabled = cfg.general.me2dc_fallback;
-                            fast_fallback_enabled = cfg.general.me2dc_fallback && cfg.general.me2dc_fast;
-                            continue;
-                        }
-                        _ = tokio::time::sleep(Duration::from_millis(admission_poll_ms)) => {}
-                    }
-                    let ready = pool_for_gate.admission_ready_conditional_cast().await;
-                    let now = Instant::now();
-                    let (next_gate_open, next_route_mode, next_fallback_reason) = if ready {
-                        ready_observed = true;
-                        not_ready_since = None;
-                        (true, RelayRouteMode::Middle, None)
-                    } else if fast_fallback_enabled {
-                        (
-                            true,
-                            RelayRouteMode::Direct,
-                            Some("fast_not_ready_fallback"),
-                        )
-                    } else {
-                        let not_ready_started_at = *not_ready_since.get_or_insert(now);
-                        let not_ready_for = now.saturating_duration_since(not_ready_started_at);
-                        let fallback_after = if ready_observed {
-                            RUNTIME_FALLBACK_AFTER
-                        } else {
-                            STARTUP_FALLBACK_AFTER
-                        };
-                        if fallback_enabled && not_ready_for > fallback_after {
-                            (true, RelayRouteMode::Direct, Some("strict_grace_fallback"))
-                        } else {
-                            (false, RelayRouteMode::Middle, None)
-                        }
-                    };
-                    let next_fallback_active = next_fallback_reason.is_some();
-
-                    if next_route_mode != route_mode {
-                        route_mode = next_route_mode;
-                        if let Some(snapshot) = route_runtime_gate.set_mode(route_mode) {
-                            if matches!(route_mode, RelayRouteMode::Middle) {
-                                info!(
-                                    target_mode = route_mode.as_str(),
-                                    cutover_generation = snapshot.generation,
-                                    "Middle-End routing restored for new sessions"
-                                );
-                            } else {
-                                let fallback_reason = next_fallback_reason.unwrap_or("unknown");
-                                if fallback_reason == "strict_grace_fallback" {
-                                    let fallback_after = if ready_observed {
-                                        RUNTIME_FALLBACK_AFTER
-                                    } else {
-                                        STARTUP_FALLBACK_AFTER
-                                    };
-                                    warn!(
-                                        target_mode = route_mode.as_str(),
-                                        cutover_generation = snapshot.generation,
-                                        grace_secs = fallback_after.as_secs(),
-                                        fallback_reason,
-                                        "ME pool stayed not-ready beyond grace; routing new sessions via Direct-DC"
-                                    );
-                                } else {
-                                    warn!(
-                                        target_mode = route_mode.as_str(),
-                                        cutover_generation = snapshot.generation,
-                                        fallback_reason,
-                                        "ME pool not-ready; routing new sessions via Direct-DC (fast mode)"
-                                    );
-                                }
-                            }
-                        }
-                    }
-
-                    if next_gate_open != gate_open {
-                        gate_open = next_gate_open;
-                        admission_tx_gate.send_replace(gate_open);
-                        if gate_open {
-                            if next_fallback_active {
-                                warn!(
-                                    fallback_reason = next_fallback_reason.unwrap_or("unknown"),
-                                    "Conditional-admission gate opened in ME fallback mode"
-                                );
-                            } else {
-                                info!("Conditional-admission gate opened / ME pool READY");
-                            }
-                        } else {
-                            warn!("Conditional-admission gate closed / ME pool is NOT ready");
-                        }
-                    }
-                }
-            });
-        } else {
-            admission_tx.send_replace(false);
-            let _ = route_runtime.set_mode(RelayRouteMode::Direct);
-            warn!("Conditional-admission gate: closed / ME pool is UNAVAILABLE");
-        }
-    } else {
-        admission_tx.send_replace(true);
-        let _ = route_runtime.set_mode(RelayRouteMode::Direct);
-    }
-}

src/maestro/connectivity.rs

@@ -1,232 +0,0 @@
-#![allow(clippy::too_many_arguments)]
-
-use std::sync::Arc;
-use std::time::Instant;
-
-use tokio::sync::RwLock;
-use tracing::info;
-
-use crate::config::ProxyConfig;
-use crate::crypto::SecureRandom;
-use crate::network::probe::NetworkDecision;
-use crate::startup::{
-    COMPONENT_DC_CONNECTIVITY_PING, COMPONENT_ME_CONNECTIVITY_PING, COMPONENT_RUNTIME_READY,
-    StartupTracker,
-};
-use crate::transport::UpstreamManager;
-use crate::transport::middle_proxy::{
-    MePingFamily, MePingSample, MePool, format_me_route, format_sample_line, run_me_ping,
-};
-
-pub(crate) async fn run_startup_connectivity(
-    config: &Arc<ProxyConfig>,
-    me_pool: &Option<Arc<MePool>>,
-    rng: Arc<SecureRandom>,
-    startup_tracker: &Arc<StartupTracker>,
-    upstream_manager: Arc<UpstreamManager>,
-    prefer_ipv6: bool,
-    decision: &NetworkDecision,
-    process_started_at: Instant,
-    api_me_pool: Arc<RwLock<Option<Arc<MePool>>>>,
-) {
-    if me_pool.is_some() {
-        startup_tracker
-            .start_component(
-                COMPONENT_ME_CONNECTIVITY_PING,
-                Some("run startup ME connectivity check".to_string()),
-            )
-            .await;
-    } else {
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_CONNECTIVITY_PING,
-                Some("ME pool is not available".to_string()),
-            )
-            .await;
-    }
-    if let Some(pool) = me_pool {
-        let me_results = run_me_ping(pool, &rng).await;
-
-        let v4_ok = me_results.iter().any(|r| {
-            matches!(r.family, MePingFamily::V4)
-                && r.samples
-                    .iter()
-                    .any(|s| s.error.is_none() && s.handshake_ms.is_some())
-        });
-        let v6_ok = me_results.iter().any(|r| {
-            matches!(r.family, MePingFamily::V6)
-                && r.samples
-                    .iter()
-                    .any(|s| s.error.is_none() && s.handshake_ms.is_some())
-        });
-
-        info!("================= Telegram ME Connectivity =================");
-        if v4_ok && v6_ok {
-            info!("  IPv4 and IPv6 available");
-        } else if v4_ok {
-            info!("  IPv4 only / IPv6 unavailable");
-        } else if v6_ok {
-            info!("  IPv6 only / IPv4 unavailable");
-        } else {
-            info!("  No ME connectivity");
-        }
-        let me_route =
-            format_me_route(&config.upstreams, &me_results, prefer_ipv6, v4_ok, v6_ok).await;
-        info!("  via {}", me_route);
-        info!("============================================================");
-
-        use std::collections::BTreeMap;
-        let mut grouped: BTreeMap<i32, Vec<MePingSample>> = BTreeMap::new();
-        for report in me_results {
-            for s in report.samples {
-                grouped.entry(s.dc).or_default().push(s);
-            }
-        }
-
-        let family_order = if prefer_ipv6 {
-            vec![MePingFamily::V6, MePingFamily::V4]
-        } else {
-            vec![MePingFamily::V4, MePingFamily::V6]
-        };
-
-        for (dc, samples) in grouped {
-            for family in &family_order {
-                let fam_samples: Vec<&MePingSample> = samples
-                    .iter()
-                    .filter(|s| matches!(s.family, f if &f == family))
-                    .collect();
-                if fam_samples.is_empty() {
-                    continue;
-                }
-
-                let fam_label = match family {
-                    MePingFamily::V4 => "IPv4",
-                    MePingFamily::V6 => "IPv6",
-                };
-                info!("    DC{} [{}]", dc, fam_label);
-                for sample in fam_samples {
-                    let line = format_sample_line(sample);
-                    info!("{}", line);
-                }
-            }
-        }
-        info!("============================================================");
-        startup_tracker
-            .complete_component(
-                COMPONENT_ME_CONNECTIVITY_PING,
-                Some("startup ME connectivity check completed".to_string()),
-            )
-            .await;
-    }
-
-    info!("================= Telegram DC Connectivity =================");
-    startup_tracker
-        .start_component(
-            COMPONENT_DC_CONNECTIVITY_PING,
-            Some("run startup DC connectivity check".to_string()),
-        )
-        .await;
-
-    let ping_results = upstream_manager
-        .ping_all_dcs(
-            prefer_ipv6,
-            &config.dc_overrides,
-            decision.ipv4_dc,
-            decision.ipv6_dc,
-        )
-        .await;
-
-    for upstream_result in &ping_results {
-        let v6_works = upstream_result
-            .v6_results
-            .iter()
-            .any(|r| r.rtt_ms.is_some());
-        let v4_works = upstream_result
-            .v4_results
-            .iter()
-            .any(|r| r.rtt_ms.is_some());
-
-        if upstream_result.both_available {
-            if prefer_ipv6 {
-                info!("  IPv6 in use / IPv4 is fallback");
-            } else {
-                info!("  IPv4 in use / IPv6 is fallback");
-            }
-        } else if v6_works && !v4_works {
-            info!("  IPv6 only / IPv4 unavailable");
-        } else if v4_works && !v6_works {
-            info!("  IPv4 only / IPv6 unavailable");
-        } else if !v6_works && !v4_works {
-            info!("  No DC connectivity");
-        }
-
-        info!("  via {}", upstream_result.upstream_name);
-        info!("============================================================");
-
-        if v6_works {
-            for dc in &upstream_result.v6_results {
-                let addr_str = format!("{}:{}", dc.dc_addr.ip(), dc.dc_addr.port());
-                match &dc.rtt_ms {
-                    Some(rtt) => {
-                        info!("    DC{} [IPv6] {} - {:.0} ms", dc.dc_idx, addr_str, rtt);
-                    }
-                    None => {
-                        let err = dc.error.as_deref().unwrap_or("fail");
-                        info!("    DC{} [IPv6] {} - FAIL ({})", dc.dc_idx, addr_str, err);
-                    }
-                }
-            }
-
-            info!("============================================================");
-        }
-
-        if v4_works {
-            for dc in &upstream_result.v4_results {
-                let addr_str = format!("{}:{}", dc.dc_addr.ip(), dc.dc_addr.port());
-                match &dc.rtt_ms {
-                    Some(rtt) => {
-                        info!(
-                            "    DC{} [IPv4] {}\t\t\t\t{:.0} ms",
-                            dc.dc_idx, addr_str, rtt
-                        );
-                    }
-                    None => {
-                        let err = dc.error.as_deref().unwrap_or("fail");
-                        info!(
-                            "    DC{} [IPv4] {}:\t\t\t\tFAIL ({})",
-                            dc.dc_idx, addr_str, err
-                        );
-                    }
-                }
-            }
-
-            info!("============================================================");
-        }
-    }
-    startup_tracker
-        .complete_component(
-            COMPONENT_DC_CONNECTIVITY_PING,
-            Some("startup DC connectivity check completed".to_string()),
-        )
-        .await;
-
-    let initialized_secs = process_started_at.elapsed().as_secs();
-    let second_suffix = if initialized_secs == 1 { "" } else { "s" };
-    startup_tracker
-        .start_component(
-            COMPONENT_RUNTIME_READY,
-            Some("finalize startup runtime state".to_string()),
-        )
-        .await;
-    info!("===================== Telegram Startup =====================");
-    info!(
-        "  DC/ME Initialized in {} second{}",
-        initialized_secs, second_suffix
-    );
-    info!("============================================================");
-
-    if let Some(pool) = me_pool {
-        pool.set_runtime_ready(true);
-    }
-    *api_me_pool.write().await = me_pool.clone();
-}

src/maestro/helpers.rs

@@ -1,548 +0,0 @@
-#![allow(clippy::items_after_test_module)]
-
-use std::path::PathBuf;
-use std::time::Duration;
-
-use tokio::sync::watch;
-use tracing::{debug, error, info, warn};
-
-use crate::cli;
-use crate::config::ProxyConfig;
-use crate::logging::LogDestination;
-use crate::transport::UpstreamManager;
-use crate::transport::middle_proxy::{
-    ProxyConfigData, fetch_proxy_config_with_raw_via_upstream, load_proxy_config_cache,
-    save_proxy_config_cache,
-};
-
-pub(crate) fn resolve_runtime_config_path(
-    config_path_cli: &str,
-    startup_cwd: &std::path::Path,
-    config_path_explicit: bool,
-) -> PathBuf {
-    if config_path_explicit {
-        let raw = PathBuf::from(config_path_cli);
-        let absolute = if raw.is_absolute() {
-            raw
-        } else {
-            startup_cwd.join(raw)
-        };
-        return absolute.canonicalize().unwrap_or(absolute);
-    }
-
-    let etc_telemt = std::path::Path::new("/etc/telemt");
-    let candidates = [
-        startup_cwd.join("config.toml"),
-        startup_cwd.join("telemt.toml"),
-        etc_telemt.join("telemt.toml"),
-        etc_telemt.join("config.toml"),
-    ];
-    for candidate in candidates {
-        if candidate.is_file() {
-            return candidate.canonicalize().unwrap_or(candidate);
-        }
-    }
-
-    startup_cwd.join("config.toml")
-}
-
-/// Parsed CLI arguments.
-pub(crate) struct CliArgs {
-    pub config_path: String,
-    pub config_path_explicit: bool,
-    pub data_path: Option<PathBuf>,
-    pub silent: bool,
-    pub log_level: Option<String>,
-    pub log_destination: LogDestination,
-}
-
-pub(crate) fn parse_cli() -> CliArgs {
-    let mut config_path = "config.toml".to_string();
-    let mut config_path_explicit = false;
-    let mut data_path: Option<PathBuf> = None;
-    let mut silent = false;
-    let mut log_level: Option<String> = None;
-
-    let args: Vec<String> = std::env::args().skip(1).collect();
-
-    // Parse log destination
-    let log_destination = crate::logging::parse_log_destination(&args);
-
-    // Check for --init first (handled before tokio)
-    if let Some(init_opts) = cli::parse_init_args(&args) {
-        if let Err(e) = cli::run_init(init_opts) {
-            eprintln!("[telemt] Init failed: {}", e);
-            std::process::exit(1);
-        }
-        std::process::exit(0);
-    }
-
-    let mut i = 0;
-    while i < args.len() {
-        match args[i].as_str() {
-            "--data-path" => {
-                i += 1;
-                if i < args.len() {
-                    data_path = Some(PathBuf::from(args[i].clone()));
-                } else {
-                    eprintln!("Missing value for --data-path");
-                    std::process::exit(0);
-                }
-            }
-            s if s.starts_with("--data-path=") => {
-                data_path = Some(PathBuf::from(
-                    s.trim_start_matches("--data-path=").to_string(),
-                ));
-            }
-            "--working-dir" => {
-                i += 1;
-                if i < args.len() {
-                    data_path = Some(PathBuf::from(args[i].clone()));
-                } else {
-                    eprintln!("Missing value for --working-dir");
-                    std::process::exit(0);
-                }
-            }
-            s if s.starts_with("--working-dir=") => {
-                data_path = Some(PathBuf::from(
-                    s.trim_start_matches("--working-dir=").to_string(),
-                ));
-            }
-            "--silent" | "-s" => {
-                silent = true;
-            }
-            "--log-level" => {
-                i += 1;
-                if i < args.len() {
-                    log_level = Some(args[i].clone());
-                }
-            }
-            s if s.starts_with("--log-level=") => {
-                log_level = Some(s.trim_start_matches("--log-level=").to_string());
-            }
-            "--help" | "-h" => {
-                print_help();
-                std::process::exit(0);
-            }
-            "--version" | "-V" => {
-                println!("telemt {}", env!("CARGO_PKG_VERSION"));
-                std::process::exit(0);
-            }
-            // Skip daemon-related flags (already parsed)
-            "--daemon" | "-d" | "--foreground" | "-f" => {}
-            s if s.starts_with("--pid-file") => {
-                if !s.contains('=') {
-                    i += 1; // skip value
-                }
-            }
-            s if s.starts_with("--run-as-user") => {
-                if !s.contains('=') {
-                    i += 1;
-                }
-            }
-            s if s.starts_with("--run-as-group") => {
-                if !s.contains('=') {
-                    i += 1;
-                }
-            }
-            s if !s.starts_with('-') => {
-                if !matches!(s, "run" | "start" | "stop" | "reload" | "status") {
-                    config_path = s.to_string();
-                    config_path_explicit = true;
-                }
-            }
-            other => {
-                eprintln!("Unknown option: {}", other);
-            }
-        }
-        i += 1;
-    }
-
-    CliArgs {
-        config_path,
-        config_path_explicit,
-        data_path,
-        silent,
-        log_level,
-        log_destination,
-    }
-}
-
-fn print_help() {
-    eprintln!("Usage: telemt [COMMAND] [OPTIONS] [config.toml]");
-    eprintln!();
-    eprintln!("Commands:");
-    eprintln!("  run                     Run in foreground (default if no command given)");
-    #[cfg(unix)]
-    {
-        eprintln!("  start                   Start as background daemon");
-        eprintln!("  stop                    Stop a running daemon");
-        eprintln!("  reload                  Reload configuration (send SIGHUP)");
-        eprintln!("  status                  Check if daemon is running");
-    }
-    eprintln!();
-    eprintln!("Options:");
-    eprintln!(
-        "  --data-path <DIR>       Set data directory (absolute path; overrides config value)"
-    );
-    eprintln!("  --working-dir <DIR>     Alias for --data-path");
-    eprintln!("  --silent, -s            Suppress info logs");
-    eprintln!("  --log-level <LEVEL>     debug|verbose|normal|silent");
-    eprintln!("  --help, -h              Show this help");
-    eprintln!("  --version, -V           Show version");
-    eprintln!();
-    eprintln!("Logging options:");
-    eprintln!("  --log-file <PATH>       Log to file (default: stderr)");
-    eprintln!("  --log-file-daily <PATH> Log to file with daily rotation");
-    #[cfg(unix)]
-    eprintln!("  --syslog                Log to syslog (Unix only)");
-    eprintln!();
-    #[cfg(unix)]
-    {
-        eprintln!("Daemon options (Unix only):");
-        eprintln!("  --daemon, -d            Fork to background (daemonize)");
-        eprintln!("  --foreground, -f        Explicit foreground mode (for systemd)");
-        eprintln!("  --pid-file <PATH>       PID file path (default: /var/run/telemt.pid)");
-        eprintln!("  --run-as-user <USER>    Drop privileges to this user after binding");
-        eprintln!("  --run-as-group <GROUP>  Drop privileges to this group after binding");
-        eprintln!("  --working-dir <DIR>     Working directory for daemon mode");
-        eprintln!();
-    }
-    eprintln!("Setup (fire-and-forget):");
-    eprintln!("  --init                  Generate config, install systemd service, start");
-    eprintln!("    --port <PORT>          Listen port (default: 443)");
-    eprintln!("    --domain <DOMAIN>      TLS domain for masking (default: www.google.com)");
-    eprintln!("    --secret <HEX>         32-char hex secret (auto-generated if omitted)");
-    eprintln!("    --user <NAME>          Username (default: user)");
-    eprintln!("    --config-dir <DIR>     Config directory (default: /etc/telemt)");
-    eprintln!("    --no-start             Don't start the service after install");
-    #[cfg(unix)]
-    {
-        eprintln!();
-        eprintln!("Examples:");
-        eprintln!("  telemt config.toml                    Run in foreground");
-        eprintln!("  telemt start config.toml              Start as daemon");
-        eprintln!("  telemt start --pid-file /tmp/t.pid    Start with custom PID file");
-        eprintln!("  telemt stop                           Stop daemon");
-        eprintln!("  telemt reload                         Reload configuration");
-        eprintln!("  telemt status                         Check daemon status");
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::resolve_runtime_config_path;
-
-    #[test]
-    fn resolve_runtime_config_path_anchors_relative_to_startup_cwd() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        let target = startup_cwd.join("config.toml");
-        std::fs::write(&target, " ").unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, true);
-        assert_eq!(resolved, target.canonicalize().unwrap());
-
-        let _ = std::fs::remove_file(&target);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_keeps_absolute_for_missing_file() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_path_missing_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-
-        let resolved = resolve_runtime_config_path("missing.toml", &startup_cwd, true);
-        assert_eq!(resolved, startup_cwd.join("missing.toml"));
-
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_uses_startup_candidates_when_not_explicit() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd =
-            std::env::temp_dir().join(format!("telemt_cfg_startup_candidates_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-        let telemt = startup_cwd.join("telemt.toml");
-        std::fs::write(&telemt, " ").unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
-        assert_eq!(resolved, telemt.canonicalize().unwrap());
-
-        let _ = std::fs::remove_file(&telemt);
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-
-    #[test]
-    fn resolve_runtime_config_path_defaults_to_startup_config_when_none_found() {
-        let nonce = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let startup_cwd = std::env::temp_dir().join(format!("telemt_cfg_startup_default_{nonce}"));
-        std::fs::create_dir_all(&startup_cwd).unwrap();
-
-        let resolved = resolve_runtime_config_path("config.toml", &startup_cwd, false);
-        assert_eq!(resolved, startup_cwd.join("config.toml"));
-
-        let _ = std::fs::remove_dir(&startup_cwd);
-    }
-}
-
-pub(crate) fn print_proxy_links(host: &str, port: u16, config: &ProxyConfig) {
-    info!(target: "telemt::links", "--- Proxy Links ({}) ---", host);
-    for user_name in config
-        .general
-        .links
-        .show
-        .resolve_users(&config.access.users)
-    {
-        if let Some(secret) = config.access.users.get(user_name) {
-            info!(target: "telemt::links", "User: {}", user_name);
-            if config.general.modes.classic {
-                info!(
-                    target: "telemt::links",
-                    "  Classic: tg://proxy?server={}&port={}&secret={}",
-                    host, port, secret
-                );
-            }
-            if config.general.modes.secure {
-                info!(
-                    target: "telemt::links",
-                    "  DD:      tg://proxy?server={}&port={}&secret=dd{}",
-                    host, port, secret
-                );
-            }
-            if config.general.modes.tls {
-                let mut domains = Vec::with_capacity(1 + config.censorship.tls_domains.len());
-                domains.push(config.censorship.tls_domain.clone());
-                for d in &config.censorship.tls_domains {
-                    if !domains.contains(d) {
-                        domains.push(d.clone());
-                    }
-                }
-
-                for domain in domains {
-                    let domain_hex = hex::encode(&domain);
-                    info!(
-                        target: "telemt::links",
-                        "  EE-TLS:  tg://proxy?server={}&port={}&secret=ee{}{}",
-                        host, port, secret, domain_hex
-                    );
-                }
-            }
-        } else {
-            warn!(target: "telemt::links", "User '{}' in show_link not found", user_name);
-        }
-    }
-    info!(target: "telemt::links", "------------------------");
-}
-
-pub(crate) async fn write_beobachten_snapshot(path: &str, payload: &str) -> std::io::Result<()> {
-    if let Some(parent) = std::path::Path::new(path).parent()
-        && !parent.as_os_str().is_empty()
-    {
-        tokio::fs::create_dir_all(parent).await?;
-    }
-    tokio::fs::write(path, payload).await
-}
-
-pub(crate) fn unit_label(value: u64, singular: &'static str, plural: &'static str) -> &'static str {
-    if value == 1 { singular } else { plural }
-}
-
-pub(crate) fn format_uptime(total_secs: u64) -> String {
-    const SECS_PER_MINUTE: u64 = 60;
-    const SECS_PER_HOUR: u64 = 60 * SECS_PER_MINUTE;
-    const SECS_PER_DAY: u64 = 24 * SECS_PER_HOUR;
-    const SECS_PER_MONTH: u64 = 30 * SECS_PER_DAY;
-    const SECS_PER_YEAR: u64 = 12 * SECS_PER_MONTH;
-
-    let mut remaining = total_secs;
-    let years = remaining / SECS_PER_YEAR;
-    remaining %= SECS_PER_YEAR;
-    let months = remaining / SECS_PER_MONTH;
-    remaining %= SECS_PER_MONTH;
-    let days = remaining / SECS_PER_DAY;
-    remaining %= SECS_PER_DAY;
-    let hours = remaining / SECS_PER_HOUR;
-    remaining %= SECS_PER_HOUR;
-    let minutes = remaining / SECS_PER_MINUTE;
-    let seconds = remaining % SECS_PER_MINUTE;
-
-    let mut parts = Vec::new();
-    if total_secs > SECS_PER_YEAR {
-        parts.push(format!("{} {}", years, unit_label(years, "year", "years")));
-    }
-    if total_secs > SECS_PER_MONTH {
-        parts.push(format!(
-            "{} {}",
-            months,
-            unit_label(months, "month", "months")
-        ));
-    }
-    if total_secs > SECS_PER_DAY {
-        parts.push(format!("{} {}", days, unit_label(days, "day", "days")));
-    }
-    if total_secs > SECS_PER_HOUR {
-        parts.push(format!("{} {}", hours, unit_label(hours, "hour", "hours")));
-    }
-    if total_secs > SECS_PER_MINUTE {
-        parts.push(format!(
-            "{} {}",
-            minutes,
-            unit_label(minutes, "minute", "minutes")
-        ));
-    }
-    parts.push(format!(
-        "{} {}",
-        seconds,
-        unit_label(seconds, "second", "seconds")
-    ));
-
-    format!("{} / {} seconds", parts.join(", "), total_secs)
-}
-
-#[allow(dead_code)]
-pub(crate) async fn wait_until_admission_open(admission_rx: &mut watch::Receiver<bool>) -> bool {
-    loop {
-        if *admission_rx.borrow() {
-            return true;
-        }
-        if admission_rx.changed().await.is_err() {
-            return *admission_rx.borrow();
-        }
-    }
-}
-
-pub(crate) fn is_expected_handshake_eof(err: &crate::error::ProxyError) -> bool {
-    err.to_string().contains("expected 64 bytes, got 0")
-}
-
-pub(crate) async fn load_startup_proxy_config_snapshot(
-    url: &str,
-    cache_path: Option<&str>,
-    me2dc_fallback: bool,
-    label: &'static str,
-    upstream: Option<std::sync::Arc<UpstreamManager>>,
-) -> Option<ProxyConfigData> {
-    loop {
-        match fetch_proxy_config_with_raw_via_upstream(url, upstream.clone()).await {
-            Ok((cfg, raw)) => {
-                if !cfg.map.is_empty() {
-                    if let Some(path) = cache_path
-                        && let Err(e) = save_proxy_config_cache(path, &raw).await
-                    {
-                        warn!(error = %e, path, snapshot = label, "Failed to store startup proxy-config cache");
-                    }
-                    return Some(cfg);
-                }
-
-                warn!(
-                    snapshot = label,
-                    url, "Startup proxy-config is empty; trying disk cache"
-                );
-                if let Some(path) = cache_path {
-                    match load_proxy_config_cache(path).await {
-                        Ok(cached) if !cached.map.is_empty() => {
-                            info!(
-                                snapshot = label,
-                                path,
-                                proxy_for_lines = cached.proxy_for_lines,
-                                "Loaded startup proxy-config from disk cache"
-                            );
-                            return Some(cached);
-                        }
-                        Ok(_) => {
-                            warn!(
-                                snapshot = label,
-                                path, "Startup proxy-config cache is empty; ignoring cache file"
-                            );
-                        }
-                        Err(cache_err) => {
-                            debug!(
-                                snapshot = label,
-                                path,
-                                error = %cache_err,
-                                "Startup proxy-config cache unavailable"
-                            );
-                        }
-                    }
-                }
-
-                if me2dc_fallback {
-                    error!(
-                        snapshot = label,
-                        "Startup proxy-config unavailable and no saved config found; falling back to direct mode"
-                    );
-                    return None;
-                }
-
-                warn!(
-                    snapshot = label,
-                    retry_in_secs = 2,
-                    "Startup proxy-config unavailable and no saved config found; retrying because me2dc_fallback=false"
-                );
-                tokio::time::sleep(Duration::from_secs(2)).await;
-            }
-            Err(fetch_err) => {
-                if let Some(path) = cache_path {
-                    match load_proxy_config_cache(path).await {
-                        Ok(cached) if !cached.map.is_empty() => {
-                            info!(
-                                snapshot = label,
-                                path,
-                                proxy_for_lines = cached.proxy_for_lines,
-                                "Loaded startup proxy-config from disk cache"
-                            );
-                            return Some(cached);
-                        }
-                        Ok(_) => {
-                            warn!(
-                                snapshot = label,
-                                path, "Startup proxy-config cache is empty; ignoring cache file"
-                            );
-                        }
-                        Err(cache_err) => {
-                            debug!(
-                                snapshot = label,
-                                path,
-                                error = %cache_err,
-                                "Startup proxy-config cache unavailable"
-                            );
-                        }
-                    }
-                }
-
-                if me2dc_fallback {
-                    error!(
-                        snapshot = label,
-                        error = %fetch_err,
-                        "Startup proxy-config unavailable and no cached data; falling back to direct mode"
-                    );
-                    return None;
-                }
-
-                warn!(
-                    snapshot = label,
-                    error = %fetch_err,
-                    retry_in_secs = 2,
-                    "Startup proxy-config unavailable; retrying because me2dc_fallback=false"
-                );
-                tokio::time::sleep(Duration::from_secs(2)).await;
-            }
-        }
-    }
-}

src/maestro/listeners.rs

@@ -1,546 +0,0 @@
-use std::error::Error;
-use std::net::{IpAddr, SocketAddr};
-use std::sync::Arc;
-use std::time::Duration;
-
-use tokio::net::TcpListener;
-#[cfg(unix)]
-use tokio::net::UnixListener;
-use tokio::sync::{Semaphore, watch};
-use tracing::{debug, error, info, warn};
-
-use crate::config::ProxyConfig;
-use crate::crypto::SecureRandom;
-use crate::ip_tracker::UserIpTracker;
-use crate::proxy::ClientHandler;
-use crate::proxy::route_mode::{ROUTE_SWITCH_ERROR_MSG, RouteRuntimeController};
-use crate::proxy::shared_state::ProxySharedState;
-use crate::startup::{COMPONENT_LISTENERS_BIND, StartupTracker};
-use crate::stats::beobachten::BeobachtenStore;
-use crate::stats::{ReplayChecker, Stats};
-use crate::stream::BufferPool;
-use crate::tls_front::TlsFrontCache;
-use crate::transport::middle_proxy::MePool;
-use crate::transport::{ListenOptions, UpstreamManager, create_listener, find_listener_processes};
-
-use super::helpers::{is_expected_handshake_eof, print_proxy_links};
-
-pub(crate) struct BoundListeners {
-    pub(crate) listeners: Vec<(TcpListener, bool)>,
-    pub(crate) has_unix_listener: bool,
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) async fn bind_listeners(
-    config: &Arc<ProxyConfig>,
-    decision_ipv4_dc: bool,
-    decision_ipv6_dc: bool,
-    detected_ip_v4: Option<IpAddr>,
-    detected_ip_v6: Option<IpAddr>,
-    startup_tracker: &Arc<StartupTracker>,
-    config_rx: watch::Receiver<Arc<ProxyConfig>>,
-    admission_rx: watch::Receiver<bool>,
-    stats: Arc<Stats>,
-    upstream_manager: Arc<UpstreamManager>,
-    replay_checker: Arc<ReplayChecker>,
-    buffer_pool: Arc<BufferPool>,
-    rng: Arc<SecureRandom>,
-    me_pool: Option<Arc<MePool>>,
-    route_runtime: Arc<RouteRuntimeController>,
-    tls_cache: Option<Arc<TlsFrontCache>>,
-    ip_tracker: Arc<UserIpTracker>,
-    beobachten: Arc<BeobachtenStore>,
-    shared: Arc<ProxySharedState>,
-    max_connections: Arc<Semaphore>,
-) -> Result<BoundListeners, Box<dyn Error>> {
-    startup_tracker
-        .start_component(
-            COMPONENT_LISTENERS_BIND,
-            Some("bind TCP/Unix listeners".to_string()),
-        )
-        .await;
-    let mut listeners = Vec::new();
-
-    for listener_conf in &config.server.listeners {
-        let addr = SocketAddr::new(listener_conf.ip, config.server.port);
-        if addr.is_ipv4() && !decision_ipv4_dc {
-            warn!(%addr, "Skipping IPv4 listener: IPv4 disabled by [network]");
-            continue;
-        }
-        if addr.is_ipv6() && !decision_ipv6_dc {
-            warn!(%addr, "Skipping IPv6 listener: IPv6 disabled by [network]");
-            continue;
-        }
-        let options = ListenOptions {
-            reuse_port: listener_conf.reuse_allow,
-            ipv6_only: listener_conf.ip.is_ipv6(),
-            backlog: config.server.listen_backlog,
-            ..Default::default()
-        };
-
-        match create_listener(addr, &options) {
-            Ok(socket) => {
-                let listener = TcpListener::from_std(socket.into())?;
-                info!("Listening on {}", addr);
-                let listener_proxy_protocol = listener_conf
-                    .proxy_protocol
-                    .unwrap_or(config.server.proxy_protocol);
-
-                let public_host = if let Some(ref announce) = listener_conf.announce {
-                    announce.clone()
-                } else if listener_conf.ip.is_unspecified() {
-                    if listener_conf.ip.is_ipv4() {
-                        detected_ip_v4
-                            .map(|ip| ip.to_string())
-                            .unwrap_or_else(|| listener_conf.ip.to_string())
-                    } else {
-                        detected_ip_v6
-                            .map(|ip| ip.to_string())
-                            .unwrap_or_else(|| listener_conf.ip.to_string())
-                    }
-                } else {
-                    listener_conf.ip.to_string()
-                };
-
-                if config.general.links.public_host.is_none()
-                    && !config.general.links.show.is_empty()
-                {
-                    let link_port = config
-                        .general
-                        .links
-                        .public_port
-                        .unwrap_or(config.server.port);
-                    print_proxy_links(&public_host, link_port, config);
-                }
-
-                listeners.push((listener, listener_proxy_protocol));
-            }
-            Err(e) => {
-                if e.kind() == std::io::ErrorKind::AddrInUse {
-                    let owners = find_listener_processes(addr);
-                    if owners.is_empty() {
-                        error!(
-                            %addr,
-                            "Failed to bind: address already in use (owner process unresolved)"
-                        );
-                    } else {
-                        for owner in owners {
-                            error!(
-                                %addr,
-                                pid = owner.pid,
-                                process = %owner.process,
-                                "Failed to bind: address already in use"
-                            );
-                        }
-                    }
-
-                    if !listener_conf.reuse_allow {
-                        error!(
-                            %addr,
-                            "reuse_allow=false; set [[server.listeners]].reuse_allow=true to allow multi-instance listening"
-                        );
-                    }
-                } else {
-                    error!("Failed to bind to {}: {}", addr, e);
-                }
-            }
-        }
-    }
-
-    if !config.general.links.show.is_empty()
-        && (config.general.links.public_host.is_some() || listeners.is_empty())
-    {
-        let (host, port) = if let Some(ref h) = config.general.links.public_host {
-            (
-                h.clone(),
-                config
-                    .general
-                    .links
-                    .public_port
-                    .unwrap_or(config.server.port),
-            )
-        } else {
-            let ip = detected_ip_v4.or(detected_ip_v6).map(|ip| ip.to_string());
-            if ip.is_none() {
-                warn!(
-                    "show_link is configured but public IP could not be detected. Set public_host in config."
-                );
-            }
-            (
-                ip.unwrap_or_else(|| "UNKNOWN".to_string()),
-                config
-                    .general
-                    .links
-                    .public_port
-                    .unwrap_or(config.server.port),
-            )
-        };
-
-        print_proxy_links(&host, port, config);
-    }
-
-    let mut has_unix_listener = false;
-    #[cfg(unix)]
-    if let Some(ref unix_path) = config.server.listen_unix_sock {
-        let _ = tokio::fs::remove_file(unix_path).await;
-
-        let unix_listener = UnixListener::bind(unix_path)?;
-
-        if let Some(ref perm_str) = config.server.listen_unix_sock_perm {
-            match u32::from_str_radix(perm_str.trim_start_matches('0'), 8) {
-                Ok(mode) => {
-                    use std::os::unix::fs::PermissionsExt;
-                    let perms = std::fs::Permissions::from_mode(mode);
-                    if let Err(e) = std::fs::set_permissions(unix_path, perms) {
-                        error!(
-                            "Failed to set unix socket permissions to {}: {}",
-                            perm_str, e
-                        );
-                    } else {
-                        info!("Listening on unix:{} (mode {})", unix_path, perm_str);
-                    }
-                }
-                Err(e) => {
-                    warn!(
-                        "Invalid listen_unix_sock_perm '{}': {}. Ignoring.",
-                        perm_str, e
-                    );
-                    info!("Listening on unix:{}", unix_path);
-                }
-            }
-        } else {
-            info!("Listening on unix:{}", unix_path);
-        }
-
-        has_unix_listener = true;
-
-        let mut config_rx_unix: watch::Receiver<Arc<ProxyConfig>> = config_rx.clone();
-        let admission_rx_unix = admission_rx.clone();
-        let stats = stats.clone();
-        let upstream_manager = upstream_manager.clone();
-        let replay_checker = replay_checker.clone();
-        let buffer_pool = buffer_pool.clone();
-        let rng = rng.clone();
-        let me_pool = me_pool.clone();
-        let route_runtime = route_runtime.clone();
-        let tls_cache = tls_cache.clone();
-        let ip_tracker = ip_tracker.clone();
-        let beobachten = beobachten.clone();
-        let shared = shared.clone();
-        let max_connections_unix = max_connections.clone();
-
-        tokio::spawn(async move {
-            let unix_conn_counter = Arc::new(std::sync::atomic::AtomicU64::new(1));
-
-            loop {
-                match unix_listener.accept().await {
-                    Ok((stream, _)) => {
-                        if !*admission_rx_unix.borrow() {
-                            drop(stream);
-                            continue;
-                        }
-                        let accept_permit_timeout_ms =
-                            config_rx_unix.borrow().server.accept_permit_timeout_ms;
-                        let permit = if accept_permit_timeout_ms == 0 {
-                            match max_connections_unix.clone().acquire_owned().await {
-                                Ok(permit) => permit,
-                                Err(_) => {
-                                    error!("Connection limiter is closed");
-                                    break;
-                                }
-                            }
-                        } else {
-                            match tokio::time::timeout(
-                                Duration::from_millis(accept_permit_timeout_ms),
-                                max_connections_unix.clone().acquire_owned(),
-                            )
-                            .await
-                            {
-                                Ok(Ok(permit)) => permit,
-                                Ok(Err(_)) => {
-                                    error!("Connection limiter is closed");
-                                    break;
-                                }
-                                Err(_) => {
-                                    stats.increment_accept_permit_timeout_total();
-                                    debug!(
-                                        timeout_ms = accept_permit_timeout_ms,
-                                        "Dropping accepted unix connection: permit wait timeout"
-                                    );
-                                    drop(stream);
-                                    continue;
-                                }
-                            }
-                        };
-                        let conn_id =
-                            unix_conn_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-                        let fake_peer =
-                            SocketAddr::from(([127, 0, 0, 1], (conn_id % 65535) as u16));
-
-                        let config = config_rx_unix.borrow_and_update().clone();
-                        let stats = stats.clone();
-                        let upstream_manager = upstream_manager.clone();
-                        let replay_checker = replay_checker.clone();
-                        let buffer_pool = buffer_pool.clone();
-                        let rng = rng.clone();
-                        let me_pool = me_pool.clone();
-                        let route_runtime = route_runtime.clone();
-                        let tls_cache = tls_cache.clone();
-                        let ip_tracker = ip_tracker.clone();
-                        let beobachten = beobachten.clone();
-                        let shared = shared.clone();
-                        let proxy_protocol_enabled = config.server.proxy_protocol;
-
-                        tokio::spawn(async move {
-                            let _permit = permit;
-                            if let Err(e) = crate::proxy::client::handle_client_stream_with_shared(
-                                stream,
-                                fake_peer,
-                                config,
-                                stats,
-                                upstream_manager,
-                                replay_checker,
-                                buffer_pool,
-                                rng,
-                                me_pool,
-                                route_runtime,
-                                tls_cache,
-                                ip_tracker,
-                                beobachten,
-                                shared,
-                                proxy_protocol_enabled,
-                            )
-                            .await
-                            {
-                                debug!(error = %e, "Unix socket connection error");
-                            }
-                        });
-                    }
-                    Err(e) => {
-                        error!("Unix socket accept error: {}", e);
-                        tokio::time::sleep(Duration::from_millis(100)).await;
-                    }
-                }
-            }
-        });
-    }
-
-    startup_tracker
-        .complete_component(
-            COMPONENT_LISTENERS_BIND,
-            Some(format!(
-                "listeners configured tcp={} unix={}",
-                listeners.len(),
-                has_unix_listener
-            )),
-        )
-        .await;
-
-    Ok(BoundListeners {
-        listeners,
-        has_unix_listener,
-    })
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn spawn_tcp_accept_loops(
-    listeners: Vec<(TcpListener, bool)>,
-    config_rx: watch::Receiver<Arc<ProxyConfig>>,
-    admission_rx: watch::Receiver<bool>,
-    stats: Arc<Stats>,
-    upstream_manager: Arc<UpstreamManager>,
-    replay_checker: Arc<ReplayChecker>,
-    buffer_pool: Arc<BufferPool>,
-    rng: Arc<SecureRandom>,
-    me_pool: Option<Arc<MePool>>,
-    route_runtime: Arc<RouteRuntimeController>,
-    tls_cache: Option<Arc<TlsFrontCache>>,
-    ip_tracker: Arc<UserIpTracker>,
-    beobachten: Arc<BeobachtenStore>,
-    shared: Arc<ProxySharedState>,
-    max_connections: Arc<Semaphore>,
-) {
-    for (listener, listener_proxy_protocol) in listeners {
-        let mut config_rx: watch::Receiver<Arc<ProxyConfig>> = config_rx.clone();
-        let admission_rx_tcp = admission_rx.clone();
-        let stats = stats.clone();
-        let upstream_manager = upstream_manager.clone();
-        let replay_checker = replay_checker.clone();
-        let buffer_pool = buffer_pool.clone();
-        let rng = rng.clone();
-        let me_pool = me_pool.clone();
-        let route_runtime = route_runtime.clone();
-        let tls_cache = tls_cache.clone();
-        let ip_tracker = ip_tracker.clone();
-        let beobachten = beobachten.clone();
-        let shared = shared.clone();
-        let max_connections_tcp = max_connections.clone();
-
-        tokio::spawn(async move {
-            loop {
-                match listener.accept().await {
-                    Ok((stream, peer_addr)) => {
-                        if !*admission_rx_tcp.borrow() {
-                            debug!(peer = %peer_addr, "Admission gate closed, dropping connection");
-                            drop(stream);
-                            continue;
-                        }
-                        let accept_permit_timeout_ms =
-                            config_rx.borrow().server.accept_permit_timeout_ms;
-                        let permit = if accept_permit_timeout_ms == 0 {
-                            match max_connections_tcp.clone().acquire_owned().await {
-                                Ok(permit) => permit,
-                                Err(_) => {
-                                    error!("Connection limiter is closed");
-                                    break;
-                                }
-                            }
-                        } else {
-                            match tokio::time::timeout(
-                                Duration::from_millis(accept_permit_timeout_ms),
-                                max_connections_tcp.clone().acquire_owned(),
-                            )
-                            .await
-                            {
-                                Ok(Ok(permit)) => permit,
-                                Ok(Err(_)) => {
-                                    error!("Connection limiter is closed");
-                                    break;
-                                }
-                                Err(_) => {
-                                    stats.increment_accept_permit_timeout_total();
-                                    debug!(
-                                        peer = %peer_addr,
-                                        timeout_ms = accept_permit_timeout_ms,
-                                        "Dropping accepted connection: permit wait timeout"
-                                    );
-                                    drop(stream);
-                                    continue;
-                                }
-                            }
-                        };
-                        let config = config_rx.borrow_and_update().clone();
-                        let stats = stats.clone();
-                        let upstream_manager = upstream_manager.clone();
-                        let replay_checker = replay_checker.clone();
-                        let buffer_pool = buffer_pool.clone();
-                        let rng = rng.clone();
-                        let me_pool = me_pool.clone();
-                        let route_runtime = route_runtime.clone();
-                        let tls_cache = tls_cache.clone();
-                        let ip_tracker = ip_tracker.clone();
-                        let beobachten = beobachten.clone();
-                        let shared = shared.clone();
-                        let proxy_protocol_enabled = listener_proxy_protocol;
-                        let real_peer_report = Arc::new(std::sync::Mutex::new(None));
-                        let real_peer_report_for_handler = real_peer_report.clone();
-
-                        tokio::spawn(async move {
-                            let _permit = permit;
-                            if let Err(e) = ClientHandler::new_with_shared(
-                                stream,
-                                peer_addr,
-                                config,
-                                stats,
-                                upstream_manager,
-                                replay_checker,
-                                buffer_pool,
-                                rng,
-                                me_pool,
-                                route_runtime,
-                                tls_cache,
-                                ip_tracker,
-                                beobachten,
-                                shared,
-                                proxy_protocol_enabled,
-                                real_peer_report_for_handler,
-                            )
-                            .run()
-                            .await
-                            {
-                                let real_peer = match real_peer_report.lock() {
-                                    Ok(guard) => *guard,
-                                    Err(_) => None,
-                                };
-                                let peer_closed = matches!(
-                                    &e,
-                                    crate::error::ProxyError::Io(ioe)
-                                        if matches!(
-                                            ioe.kind(),
-                                            std::io::ErrorKind::ConnectionReset
-                                                | std::io::ErrorKind::ConnectionAborted
-                                                | std::io::ErrorKind::BrokenPipe
-                                                | std::io::ErrorKind::NotConnected
-                                        )
-                                ) || matches!(
-                                    &e,
-                                    crate::error::ProxyError::Stream(
-                                        crate::error::StreamError::Io(ioe)
-                                    )
-                                        if matches!(
-                                            ioe.kind(),
-                                            std::io::ErrorKind::ConnectionReset
-                                                | std::io::ErrorKind::ConnectionAborted
-                                                | std::io::ErrorKind::BrokenPipe
-                                                | std::io::ErrorKind::NotConnected
-                                        )
-                                );
-
-                                let me_closed = matches!(
-                                    &e,
-                                    crate::error::ProxyError::Proxy(msg) if msg == "ME connection lost"
-                                );
-                                let route_switched = matches!(
-                                    &e,
-                                    crate::error::ProxyError::Proxy(msg) if msg == ROUTE_SWITCH_ERROR_MSG
-                                );
-
-                                match (peer_closed, me_closed) {
-                                    (true, _) => {
-                                        if let Some(real_peer) = real_peer {
-                                            debug!(peer = %peer_addr, real_peer = %real_peer, error = %e, "Connection closed by client");
-                                        } else {
-                                            debug!(peer = %peer_addr, error = %e, "Connection closed by client");
-                                        }
-                                    }
-                                    (_, true) => {
-                                        if let Some(real_peer) = real_peer {
-                                            warn!(peer = %peer_addr, real_peer = %real_peer, error = %e, "Connection closed: Middle-End dropped session");
-                                        } else {
-                                            warn!(peer = %peer_addr, error = %e, "Connection closed: Middle-End dropped session");
-                                        }
-                                    }
-                                    _ if route_switched => {
-                                        if let Some(real_peer) = real_peer {
-                                            info!(peer = %peer_addr, real_peer = %real_peer, error = %e, "Connection closed by controlled route cutover");
-                                        } else {
-                                            info!(peer = %peer_addr, error = %e, "Connection closed by controlled route cutover");
-                                        }
-                                    }
-                                    _ if is_expected_handshake_eof(&e) => {
-                                        if let Some(real_peer) = real_peer {
-                                            info!(peer = %peer_addr, real_peer = %real_peer, error = %e, "Connection closed during initial handshake");
-                                        } else {
-                                            info!(peer = %peer_addr, error = %e, "Connection closed during initial handshake");
-                                        }
-                                    }
-                                    _ => {
-                                        if let Some(real_peer) = real_peer {
-                                            warn!(peer = %peer_addr, real_peer = %real_peer, error = %e, "Connection closed with error");
-                                        } else {
-                                            warn!(peer = %peer_addr, error = %e, "Connection closed with error");
-                                        }
-                                    }
-                                }
-                            }
-                        });
-                    }
-                    Err(e) => {
-                        error!("Accept error: {}", e);
-                        tokio::time::sleep(Duration::from_millis(100)).await;
-                    }
-                }
-            }
-        });
-    }
-}

src/maestro/me_startup.rs

@@ -1,646 +0,0 @@
-#![allow(clippy::too_many_arguments)]
-
-use std::sync::Arc;
-use std::time::Duration;
-
-use tokio::sync::RwLock;
-use tracing::{error, info, warn};
-
-use crate::config::ProxyConfig;
-use crate::crypto::SecureRandom;
-use crate::network::probe::{NetworkDecision, NetworkProbe};
-use crate::startup::{
-    COMPONENT_ME_POOL_CONSTRUCT, COMPONENT_ME_POOL_INIT_STAGE1, COMPONENT_ME_PROXY_CONFIG_V4,
-    COMPONENT_ME_PROXY_CONFIG_V6, COMPONENT_ME_SECRET_FETCH, StartupMeStatus, StartupTracker,
-};
-use crate::stats::Stats;
-use crate::transport::UpstreamManager;
-use crate::transport::middle_proxy::MePool;
-
-use super::helpers::load_startup_proxy_config_snapshot;
-
-pub(crate) async fn initialize_me_pool(
-    use_middle_proxy: bool,
-    config: &ProxyConfig,
-    decision: &NetworkDecision,
-    probe: &NetworkProbe,
-    startup_tracker: &Arc<StartupTracker>,
-    upstream_manager: Arc<UpstreamManager>,
-    rng: Arc<SecureRandom>,
-    stats: Arc<Stats>,
-    api_me_pool: Arc<RwLock<Option<Arc<MePool>>>>,
-) -> Option<Arc<MePool>> {
-    if !use_middle_proxy {
-        return None;
-    }
-
-    info!("=== Middle Proxy Mode ===");
-    let me_nat_probe = config.general.middle_proxy_nat_probe && config.network.stun_use;
-    if config.general.middle_proxy_nat_probe && !config.network.stun_use {
-        info!("Middle-proxy STUN probing disabled by network.stun_use=false");
-    }
-
-    let me2dc_fallback = config.general.me2dc_fallback;
-    let me_init_retry_attempts = config.general.me_init_retry_attempts;
-    let me_init_warn_after_attempts: u32 = 3;
-
-    // Global ad_tag (pool default). Used when user has no per-user tag in access.user_ad_tags.
-    let proxy_tag = config
-        .general
-        .ad_tag
-        .as_ref()
-        .map(|tag| hex::decode(tag).expect("general.ad_tag must be validated before startup"));
-
-    // =============================================================
-    // CRITICAL: Download Telegram proxy-secret (NOT user secret!)
-    //
-    // C MTProxy uses TWO separate secrets:
-    //   -S flag    = 16-byte user secret for client obfuscation
-    //   --aes-pwd  = 32-512 byte binary file for ME RPC auth
-    //
-    // proxy-secret is from: https://core.telegram.org/getProxySecret
-    // =============================================================
-    let proxy_secret_path = config.general.proxy_secret_path.as_deref();
-    let pool_size = config.general.middle_proxy_pool_size.max(1);
-    let proxy_secret = loop {
-        match crate::transport::middle_proxy::fetch_proxy_secret_with_upstream(
-            proxy_secret_path,
-            config.general.proxy_secret_len_max,
-            Some(upstream_manager.clone()),
-        )
-        .await
-        {
-            Ok(proxy_secret) => break Some(proxy_secret),
-            Err(e) => {
-                startup_tracker.set_me_last_error(Some(e.to_string())).await;
-                if me2dc_fallback {
-                    error!(
-                        error = %e,
-                        "ME startup failed: proxy-secret is unavailable and no saved secret found; falling back to direct mode"
-                    );
-                    break None;
-                }
-
-                warn!(
-                    error = %e,
-                    retry_in_secs = 2,
-                    "ME startup failed: proxy-secret is unavailable and no saved secret found; retrying because me2dc_fallback=false"
-                );
-                tokio::time::sleep(Duration::from_secs(2)).await;
-            }
-        }
-    };
-    match proxy_secret {
-        Some(proxy_secret) => {
-            startup_tracker
-                .complete_component(
-                    COMPONENT_ME_SECRET_FETCH,
-                    Some("proxy-secret loaded".to_string()),
-                )
-                .await;
-            info!(
-                secret_len = proxy_secret.len(),
-                key_sig = format_args!(
-                    "0x{:08x}",
-                    if proxy_secret.len() >= 4 {
-                        u32::from_le_bytes([
-                            proxy_secret[0],
-                            proxy_secret[1],
-                            proxy_secret[2],
-                            proxy_secret[3],
-                        ])
-                    } else {
-                        0
-                    }
-                ),
-                "Proxy-secret loaded"
-            );
-
-            startup_tracker
-                .start_component(
-                    COMPONENT_ME_PROXY_CONFIG_V4,
-                    Some("load startup proxy-config v4".to_string()),
-                )
-                .await;
-            startup_tracker
-                .set_me_status(StartupMeStatus::Initializing, COMPONENT_ME_PROXY_CONFIG_V4)
-                .await;
-            let cfg_v4 = load_startup_proxy_config_snapshot(
-                "https://core.telegram.org/getProxyConfig",
-                config.general.proxy_config_v4_cache_path.as_deref(),
-                me2dc_fallback,
-                "getProxyConfig",
-                Some(upstream_manager.clone()),
-            )
-            .await;
-            if cfg_v4.is_some() {
-                startup_tracker
-                    .complete_component(
-                        COMPONENT_ME_PROXY_CONFIG_V4,
-                        Some("proxy-config v4 loaded".to_string()),
-                    )
-                    .await;
-            } else {
-                startup_tracker
-                    .fail_component(
-                        COMPONENT_ME_PROXY_CONFIG_V4,
-                        Some("proxy-config v4 unavailable".to_string()),
-                    )
-                    .await;
-            }
-            startup_tracker
-                .start_component(
-                    COMPONENT_ME_PROXY_CONFIG_V6,
-                    Some("load startup proxy-config v6".to_string()),
-                )
-                .await;
-            startup_tracker
-                .set_me_status(StartupMeStatus::Initializing, COMPONENT_ME_PROXY_CONFIG_V6)
-                .await;
-            let cfg_v6 = load_startup_proxy_config_snapshot(
-                "https://core.telegram.org/getProxyConfigV6",
-                config.general.proxy_config_v6_cache_path.as_deref(),
-                me2dc_fallback,
-                "getProxyConfigV6",
-                Some(upstream_manager.clone()),
-            )
-            .await;
-            if cfg_v6.is_some() {
-                startup_tracker
-                    .complete_component(
-                        COMPONENT_ME_PROXY_CONFIG_V6,
-                        Some("proxy-config v6 loaded".to_string()),
-                    )
-                    .await;
-            } else {
-                startup_tracker
-                    .fail_component(
-                        COMPONENT_ME_PROXY_CONFIG_V6,
-                        Some("proxy-config v6 unavailable".to_string()),
-                    )
-                    .await;
-            }
-
-            if let (Some(cfg_v4), Some(cfg_v6)) = (cfg_v4, cfg_v6) {
-                startup_tracker
-                    .start_component(
-                        COMPONENT_ME_POOL_CONSTRUCT,
-                        Some("construct ME pool".to_string()),
-                    )
-                    .await;
-                startup_tracker
-                    .set_me_status(StartupMeStatus::Initializing, COMPONENT_ME_POOL_CONSTRUCT)
-                    .await;
-                let pool = MePool::new(
-                    proxy_tag.clone(),
-                    proxy_secret,
-                    config.general.middle_proxy_nat_ip,
-                    me_nat_probe,
-                    None,
-                    config.network.stun_servers.clone(),
-                    config.general.stun_nat_probe_concurrency,
-                    probe.detected_ipv6,
-                    config.timeouts.me_one_retry,
-                    config.timeouts.me_one_timeout_ms,
-                    cfg_v4.map.clone(),
-                    cfg_v6.map.clone(),
-                    cfg_v4.default_dc.or(cfg_v6.default_dc),
-                    decision.clone(),
-                    Some(upstream_manager.clone()),
-                    rng.clone(),
-                    stats.clone(),
-                    config.general.me_keepalive_enabled,
-                    config.general.me_keepalive_interval_secs,
-                    config.general.me_keepalive_jitter_secs,
-                    config.general.me_keepalive_payload_random,
-                    config.general.rpc_proxy_req_every,
-                    config.general.me_warmup_stagger_enabled,
-                    config.general.me_warmup_step_delay_ms,
-                    config.general.me_warmup_step_jitter_ms,
-                    config.general.me_reconnect_max_concurrent_per_dc,
-                    config.general.me_reconnect_backoff_base_ms,
-                    config.general.me_reconnect_backoff_cap_ms,
-                    config.general.me_reconnect_fast_retry_count,
-                    config.general.me_single_endpoint_shadow_writers,
-                    config.general.me_single_endpoint_outage_mode_enabled,
-                    config.general.me_single_endpoint_outage_disable_quarantine,
-                    config.general.me_single_endpoint_outage_backoff_min_ms,
-                    config.general.me_single_endpoint_outage_backoff_max_ms,
-                    config.general.me_single_endpoint_shadow_rotate_every_secs,
-                    config.general.me_floor_mode,
-                    config.general.me_adaptive_floor_idle_secs,
-                    config.general.me_adaptive_floor_min_writers_single_endpoint,
-                    config.general.me_adaptive_floor_min_writers_multi_endpoint,
-                    config.general.me_adaptive_floor_recover_grace_secs,
-                    config.general.me_adaptive_floor_writers_per_core_total,
-                    config.general.me_adaptive_floor_cpu_cores_override,
-                    config
-                        .general
-                        .me_adaptive_floor_max_extra_writers_single_per_core,
-                    config
-                        .general
-                        .me_adaptive_floor_max_extra_writers_multi_per_core,
-                    config.general.me_adaptive_floor_max_active_writers_per_core,
-                    config.general.me_adaptive_floor_max_warm_writers_per_core,
-                    config.general.me_adaptive_floor_max_active_writers_global,
-                    config.general.me_adaptive_floor_max_warm_writers_global,
-                    config.general.hardswap,
-                    config.general.me_pool_drain_ttl_secs,
-                    config.general.me_instadrain,
-                    config.general.me_pool_drain_threshold,
-                    config.general.me_pool_drain_soft_evict_enabled,
-                    config.general.me_pool_drain_soft_evict_grace_secs,
-                    config.general.me_pool_drain_soft_evict_per_writer,
-                    config.general.me_pool_drain_soft_evict_budget_per_core,
-                    config.general.me_pool_drain_soft_evict_cooldown_ms,
-                    config.general.effective_me_pool_force_close_secs(),
-                    config.general.me_pool_min_fresh_ratio,
-                    config.general.me_hardswap_warmup_delay_min_ms,
-                    config.general.me_hardswap_warmup_delay_max_ms,
-                    config.general.me_hardswap_warmup_extra_passes,
-                    config.general.me_hardswap_warmup_pass_backoff_base_ms,
-                    config.general.me_bind_stale_mode,
-                    config.general.me_bind_stale_ttl_secs,
-                    config.general.me_secret_atomic_snapshot,
-                    config.general.me_deterministic_writer_sort,
-                    config.general.me_writer_pick_mode,
-                    config.general.me_writer_pick_sample_size,
-                    config.general.me_socks_kdf_policy,
-                    config.general.me_writer_cmd_channel_capacity,
-                    config.general.me_route_channel_capacity,
-                    config.general.me_route_backpressure_base_timeout_ms,
-                    config.general.me_route_backpressure_high_timeout_ms,
-                    config.general.me_route_backpressure_high_watermark_pct,
-                    config.general.me_reader_route_data_wait_ms,
-                    config.general.me_health_interval_ms_unhealthy,
-                    config.general.me_health_interval_ms_healthy,
-                    config.general.me_warn_rate_limit_ms,
-                    config.general.me_route_no_writer_mode,
-                    config.general.me_route_no_writer_wait_ms,
-                    config.general.me_route_hybrid_max_wait_ms,
-                    config.general.me_route_blocking_send_timeout_ms,
-                    config.general.me_route_inline_recovery_attempts,
-                    config.general.me_route_inline_recovery_wait_ms,
-                );
-                startup_tracker
-                    .complete_component(
-                        COMPONENT_ME_POOL_CONSTRUCT,
-                        Some("ME pool object created".to_string()),
-                    )
-                    .await;
-                *api_me_pool.write().await = Some(pool.clone());
-                startup_tracker
-                    .start_component(
-                        COMPONENT_ME_POOL_INIT_STAGE1,
-                        Some("initialize ME pool writers".to_string()),
-                    )
-                    .await;
-                startup_tracker
-                    .set_me_status(StartupMeStatus::Initializing, COMPONENT_ME_POOL_INIT_STAGE1)
-                    .await;
-
-                if me2dc_fallback {
-                    let pool_bg = pool.clone();
-                    let rng_bg = rng.clone();
-                    let startup_tracker_bg = startup_tracker.clone();
-                    let retry_limit = if me_init_retry_attempts == 0 {
-                        String::from("unlimited")
-                    } else {
-                        me_init_retry_attempts.to_string()
-                    };
-                    std::thread::spawn(move || {
-                        let runtime = match tokio::runtime::Builder::new_current_thread()
-                            .enable_all()
-                            .build()
-                        {
-                            Ok(runtime) => runtime,
-                            Err(error) => {
-                                error!(error = %error, "Failed to build background runtime for ME initialization");
-                                return;
-                            }
-                        };
-                        runtime.block_on(async move {
-                            let mut init_attempt: u32 = 0;
-                            loop {
-                                init_attempt = init_attempt.saturating_add(1);
-                                startup_tracker_bg.set_me_init_attempt(init_attempt).await;
-                                match pool_bg.init(pool_size, &rng_bg).await {
-                                    Ok(()) => {
-                                        startup_tracker_bg.set_me_last_error(None).await;
-                                        startup_tracker_bg
-                                            .complete_component(
-                                                COMPONENT_ME_POOL_INIT_STAGE1,
-                                                Some("ME pool initialized".to_string()),
-                                            )
-                                            .await;
-                                        startup_tracker_bg
-                                            .set_me_status(StartupMeStatus::Ready, "ready")
-                                            .await;
-                                        info!(
-                                            attempt = init_attempt,
-                                            "Middle-End pool initialized successfully"
-                                        );
-
-                                            // ── Supervised background tasks ──────────────────
-                                            // Each task runs inside a nested tokio::spawn so
-                                            // that a panic is caught via JoinHandle and the
-                                            // outer loop restarts the task automatically.
-                                            let pool_health = pool_bg.clone();
-                                            let rng_health = rng_bg.clone();
-                                            let min_conns = pool_size;
-                                            tokio::spawn(async move {
-                                                loop {
-                                                    let p = pool_health.clone();
-                                                    let r = rng_health.clone();
-                                                    let res = tokio::spawn(async move {
-                                                        crate::transport::middle_proxy::me_health_monitor(
-                                                            p, r, min_conns,
-                                                        )
-                                                        .await;
-                                                    })
-                                                    .await;
-                                                    match res {
-                                                        Ok(()) => warn!("me_health_monitor exited unexpectedly, restarting"),
-                                                        Err(e) => {
-                                                            error!(error = %e, "me_health_monitor panicked, restarting in 1s");
-                                                            tokio::time::sleep(Duration::from_secs(1)).await;
-                                                        }
-                                                    }
-                                                }
-                                            });
-                                            let pool_drain_enforcer = pool_bg.clone();
-                                            tokio::spawn(async move {
-                                                loop {
-                                                    let p = pool_drain_enforcer.clone();
-                                                    let res = tokio::spawn(async move {
-                                                        crate::transport::middle_proxy::me_drain_timeout_enforcer(p).await;
-                                                    })
-                                                    .await;
-                                                    match res {
-                                                        Ok(()) => warn!("me_drain_timeout_enforcer exited unexpectedly, restarting"),
-                                                        Err(e) => {
-                                                            error!(error = %e, "me_drain_timeout_enforcer panicked, restarting in 1s");
-                                                            tokio::time::sleep(Duration::from_secs(1)).await;
-                                                        }
-                                                    }
-                                                }
-                                            });
-                                            let pool_watchdog = pool_bg.clone();
-                                            tokio::spawn(async move {
-                                                loop {
-                                                    let p = pool_watchdog.clone();
-                                                    let res = tokio::spawn(async move {
-                                                        crate::transport::middle_proxy::me_zombie_writer_watchdog(p).await;
-                                                    })
-                                                    .await;
-                                                    match res {
-                                                        Ok(()) => warn!("me_zombie_writer_watchdog exited unexpectedly, restarting"),
-                                                        Err(e) => {
-                                                            error!(error = %e, "me_zombie_writer_watchdog panicked, restarting in 1s");
-                                                            tokio::time::sleep(Duration::from_secs(1)).await;
-                                                        }
-                                                    }
-                                                }
-                                            });
-                                            // CRITICAL: keep the current-thread runtime
-                                            // alive. Without this, block_on() returns,
-                                            // the Runtime is dropped, and ALL spawned
-                                            // background tasks (health monitor, drain
-                                            // enforcer, zombie watchdog) are silently
-                                            // cancelled — causing the draining-writer
-                                            // leak that brought us here.
-                                            std::future::pending::<()>().await;
-                                            unreachable!();
-                                    }
-                                    Err(e) => {
-                                        startup_tracker_bg.set_me_last_error(Some(e.to_string())).await;
-                                        if init_attempt >= me_init_warn_after_attempts {
-                                            warn!(
-                                                error = %e,
-                                                attempt = init_attempt,
-                                                retry_limit = %retry_limit,
-                                                retry_in_secs = 2,
-                                                "ME pool is not ready yet; retrying background initialization"
-                                            );
-                                        } else {
-                                            info!(
-                                                error = %e,
-                                                attempt = init_attempt,
-                                                retry_limit = %retry_limit,
-                                                retry_in_secs = 2,
-                                                "ME pool startup warmup: retrying background initialization"
-                                            );
-                                        }
-                                        pool_bg.reset_stun_state();
-                                        tokio::time::sleep(Duration::from_secs(2)).await;
-                                    }
-                                }
-                            }
-                        });
-                    });
-                    startup_tracker
-                        .set_me_status(StartupMeStatus::Initializing, "background_init")
-                        .await;
-                    info!(
-                        startup_grace_secs = 80,
-                        "ME pool initialization continues in background; startup continues with conditional Direct fallback"
-                    );
-                    Some(pool)
-                } else {
-                    let mut init_attempt: u32 = 0;
-                    loop {
-                        init_attempt = init_attempt.saturating_add(1);
-                        startup_tracker.set_me_init_attempt(init_attempt).await;
-                        match pool.init(pool_size, &rng).await {
-                            Ok(()) => {
-                                startup_tracker.set_me_last_error(None).await;
-                                startup_tracker
-                                    .complete_component(
-                                        COMPONENT_ME_POOL_INIT_STAGE1,
-                                        Some("ME pool initialized".to_string()),
-                                    )
-                                    .await;
-                                startup_tracker
-                                    .set_me_status(StartupMeStatus::Ready, "ready")
-                                    .await;
-                                info!(
-                                    attempt = init_attempt,
-                                    "Middle-End pool initialized successfully"
-                                );
-
-                                // ── Supervised background tasks ──────────────────
-                                let pool_clone = pool.clone();
-                                let rng_clone = rng.clone();
-                                let min_conns = pool_size;
-                                tokio::spawn(async move {
-                                    loop {
-                                        let p = pool_clone.clone();
-                                        let r = rng_clone.clone();
-                                        let res = tokio::spawn(async move {
-                                            crate::transport::middle_proxy::me_health_monitor(
-                                                p, r, min_conns,
-                                            )
-                                            .await;
-                                        })
-                                        .await;
-                                        match res {
-                                            Ok(()) => warn!(
-                                                "me_health_monitor exited unexpectedly, restarting"
-                                            ),
-                                            Err(e) => {
-                                                error!(error = %e, "me_health_monitor panicked, restarting in 1s");
-                                                tokio::time::sleep(Duration::from_secs(1)).await;
-                                            }
-                                        }
-                                    }
-                                });
-                                let pool_drain_enforcer = pool.clone();
-                                tokio::spawn(async move {
-                                    loop {
-                                        let p = pool_drain_enforcer.clone();
-                                        let res = tokio::spawn(async move {
-                                                crate::transport::middle_proxy::me_drain_timeout_enforcer(p).await;
-                                            })
-                                            .await;
-                                        match res {
-                                            Ok(()) => warn!(
-                                                "me_drain_timeout_enforcer exited unexpectedly, restarting"
-                                            ),
-                                            Err(e) => {
-                                                error!(error = %e, "me_drain_timeout_enforcer panicked, restarting in 1s");
-                                                tokio::time::sleep(Duration::from_secs(1)).await;
-                                            }
-                                        }
-                                    }
-                                });
-                                let pool_watchdog = pool.clone();
-                                tokio::spawn(async move {
-                                    loop {
-                                        let p = pool_watchdog.clone();
-                                        let res = tokio::spawn(async move {
-                                                crate::transport::middle_proxy::me_zombie_writer_watchdog(p).await;
-                                            })
-                                            .await;
-                                        match res {
-                                            Ok(()) => warn!(
-                                                "me_zombie_writer_watchdog exited unexpectedly, restarting"
-                                            ),
-                                            Err(e) => {
-                                                error!(error = %e, "me_zombie_writer_watchdog panicked, restarting in 1s");
-                                                tokio::time::sleep(Duration::from_secs(1)).await;
-                                            }
-                                        }
-                                    }
-                                });
-
-                                break Some(pool);
-                            }
-                            Err(e) => {
-                                startup_tracker.set_me_last_error(Some(e.to_string())).await;
-                                let retries_limited = me_init_retry_attempts > 0;
-                                if retries_limited && init_attempt >= me_init_retry_attempts {
-                                    startup_tracker
-                                        .fail_component(
-                                            COMPONENT_ME_POOL_INIT_STAGE1,
-                                            Some("ME init retry budget exhausted".to_string()),
-                                        )
-                                        .await;
-                                    startup_tracker
-                                        .set_me_status(StartupMeStatus::Failed, "failed")
-                                        .await;
-                                    error!(
-                                        error = %e,
-                                        attempt = init_attempt,
-                                        retry_limit = me_init_retry_attempts,
-                                        "ME pool init retries exhausted; startup cannot continue in middle-proxy mode"
-                                    );
-                                    break None;
-                                }
-
-                                let retry_limit = if me_init_retry_attempts == 0 {
-                                    String::from("unlimited")
-                                } else {
-                                    me_init_retry_attempts.to_string()
-                                };
-                                if init_attempt >= me_init_warn_after_attempts {
-                                    warn!(
-                                        error = %e,
-                                        attempt = init_attempt,
-                                        retry_limit = retry_limit,
-                                        me2dc_fallback = me2dc_fallback,
-                                        retry_in_secs = 2,
-                                        "ME pool is not ready yet; retrying startup initialization"
-                                    );
-                                } else {
-                                    info!(
-                                        error = %e,
-                                        attempt = init_attempt,
-                                        retry_limit = retry_limit,
-                                        me2dc_fallback = me2dc_fallback,
-                                        retry_in_secs = 2,
-                                        "ME pool startup warmup: retrying initialization"
-                                    );
-                                }
-                                pool.reset_stun_state();
-                                tokio::time::sleep(Duration::from_secs(2)).await;
-                            }
-                        }
-                    }
-                }
-            } else {
-                startup_tracker
-                    .skip_component(
-                        COMPONENT_ME_POOL_CONSTRUCT,
-                        Some("ME configs are incomplete".to_string()),
-                    )
-                    .await;
-                startup_tracker
-                    .fail_component(
-                        COMPONENT_ME_POOL_INIT_STAGE1,
-                        Some("ME configs are incomplete".to_string()),
-                    )
-                    .await;
-                startup_tracker
-                    .set_me_status(StartupMeStatus::Failed, "failed")
-                    .await;
-                None
-            }
-        }
-        None => {
-            startup_tracker
-                .fail_component(
-                    COMPONENT_ME_SECRET_FETCH,
-                    Some("proxy-secret unavailable".to_string()),
-                )
-                .await;
-            startup_tracker
-                .skip_component(
-                    COMPONENT_ME_PROXY_CONFIG_V4,
-                    Some("proxy-secret unavailable".to_string()),
-                )
-                .await;
-            startup_tracker
-                .skip_component(
-                    COMPONENT_ME_PROXY_CONFIG_V6,
-                    Some("proxy-secret unavailable".to_string()),
-                )
-                .await;
-            startup_tracker
-                .skip_component(
-                    COMPONENT_ME_POOL_CONSTRUCT,
-                    Some("proxy-secret unavailable".to_string()),
-                )
-                .await;
-            startup_tracker
-                .fail_component(
-                    COMPONENT_ME_POOL_INIT_STAGE1,
-                    Some("proxy-secret unavailable".to_string()),
-                )
-                .await;
-            startup_tracker
-                .set_me_status(StartupMeStatus::Failed, "failed")
-                .await;
-            None
-        }
-    }
-}

src/maestro/mod.rs

@@ -1,816 +0,0 @@
-//! telemt — Telegram MTProto Proxy
-
-#![allow(unused_assignments)]
-
-// Runtime orchestration modules.
-// - helpers: CLI and shared startup/runtime helper routines.
-// - tls_bootstrap: TLS front cache bootstrap and refresh tasks.
-// - me_startup: Middle-End secret/config fetch and pool initialization.
-// - connectivity: startup ME/DC connectivity diagnostics.
-// - runtime_tasks: hot-reload and background task orchestration.
-// - admission: conditional-cast gate and route mode switching.
-// - listeners: TCP/Unix listener bind and accept-loop orchestration.
-// - shutdown: graceful shutdown sequence and uptime logging.
-mod admission;
-mod connectivity;
-mod helpers;
-mod listeners;
-mod me_startup;
-mod runtime_tasks;
-mod shutdown;
-mod tls_bootstrap;
-
-use std::net::{IpAddr, SocketAddr};
-use std::sync::Arc;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
-use tokio::sync::{RwLock, Semaphore, watch};
-use tracing::{error, info, warn};
-use tracing_subscriber::{EnvFilter, fmt, prelude::*, reload};
-
-use crate::api;
-use crate::config::{LogLevel, ProxyConfig};
-use crate::conntrack_control;
-use crate::crypto::SecureRandom;
-use crate::ip_tracker::UserIpTracker;
-use crate::network::probe::{decide_network_capabilities, log_probe_result, run_probe};
-use crate::proxy::route_mode::{RelayRouteMode, RouteRuntimeController};
-use crate::proxy::shared_state::ProxySharedState;
-use crate::startup::{
-    COMPONENT_API_BOOTSTRAP, COMPONENT_CONFIG_LOAD, COMPONENT_ME_POOL_CONSTRUCT,
-    COMPONENT_ME_POOL_INIT_STAGE1, COMPONENT_ME_PROXY_CONFIG_V4, COMPONENT_ME_PROXY_CONFIG_V6,
-    COMPONENT_ME_SECRET_FETCH, COMPONENT_NETWORK_PROBE, COMPONENT_TRACING_INIT, StartupMeStatus,
-    StartupTracker,
-};
-use crate::stats::beobachten::BeobachtenStore;
-use crate::stats::telemetry::TelemetryPolicy;
-use crate::stats::{ReplayChecker, Stats};
-use crate::stream::BufferPool;
-use crate::transport::UpstreamManager;
-use crate::transport::middle_proxy::MePool;
-use helpers::{parse_cli, resolve_runtime_config_path};
-
-#[cfg(unix)]
-use crate::daemon::{DaemonOptions, PidFile, drop_privileges};
-
-/// Runs the full telemt runtime startup pipeline and blocks until shutdown.
-///
-/// On Unix, daemon options should be handled before calling this function
-/// (daemonization must happen before tokio runtime starts).
-#[cfg(unix)]
-pub async fn run_with_daemon(
-    daemon_opts: DaemonOptions,
-) -> std::result::Result<(), Box<dyn std::error::Error>> {
-    run_inner(daemon_opts).await
-}
-
-/// Runs the full telemt runtime startup pipeline and blocks until shutdown.
-///
-/// This is the main entry point for non-daemon mode or when called as a library.
-#[allow(dead_code)]
-pub async fn run() -> std::result::Result<(), Box<dyn std::error::Error>> {
-    #[cfg(unix)]
-    {
-        // Parse CLI to get daemon options even in simple run() path
-        let args: Vec<String> = std::env::args().skip(1).collect();
-        let daemon_opts = crate::cli::parse_daemon_args(&args);
-        run_inner(daemon_opts).await
-    }
-    #[cfg(not(unix))]
-    {
-        run_inner().await
-    }
-}
-
-#[cfg(unix)]
-async fn run_inner(
-    daemon_opts: DaemonOptions,
-) -> std::result::Result<(), Box<dyn std::error::Error>> {
-    // Acquire PID file if daemonizing or if explicitly requested
-    // Keep it alive until shutdown (underscore prefix = intentionally kept for RAII cleanup)
-    let _pid_file = if daemon_opts.daemonize || daemon_opts.pid_file.is_some() {
-        let mut pf = PidFile::new(daemon_opts.pid_file_path());
-        if let Err(e) = pf.acquire() {
-            eprintln!("[telemt] {}", e);
-            std::process::exit(1);
-        }
-        Some(pf)
-    } else {
-        None
-    };
-
-    let process_started_at = Instant::now();
-    let process_started_at_epoch_secs = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs();
-    let startup_tracker = Arc::new(StartupTracker::new(process_started_at_epoch_secs));
-    startup_tracker
-        .start_component(
-            COMPONENT_CONFIG_LOAD,
-            Some("load and validate config".to_string()),
-        )
-        .await;
-    let cli_args = parse_cli();
-    let config_path_cli = cli_args.config_path;
-    let config_path_explicit = cli_args.config_path_explicit;
-    let data_path = cli_args.data_path;
-    let cli_silent = cli_args.silent;
-    let cli_log_level = cli_args.log_level;
-    let log_destination = cli_args.log_destination;
-    let startup_cwd = match std::env::current_dir() {
-        Ok(cwd) => cwd,
-        Err(e) => {
-            eprintln!("[telemt] Can't read current_dir: {}", e);
-            std::process::exit(1);
-        }
-    };
-    let mut config_path =
-        resolve_runtime_config_path(&config_path_cli, &startup_cwd, config_path_explicit);
-
-    let mut config = match ProxyConfig::load(&config_path) {
-        Ok(c) => c,
-        Err(e) => {
-            if config_path.exists() {
-                eprintln!("[telemt] Error: {}", e);
-                std::process::exit(1);
-            } else {
-                let default = ProxyConfig::default();
-
-                let serialized =
-                    match toml::to_string_pretty(&default).or_else(|_| toml::to_string(&default)) {
-                        Ok(value) => Some(value),
-                        Err(serialize_error) => {
-                            eprintln!(
-                                "[telemt] Warning: failed to serialize default config: {}",
-                                serialize_error
-                            );
-                            None
-                        }
-                    };
-
-                if config_path_explicit {
-                    if let Some(serialized) = serialized.as_ref() {
-                        if let Err(write_error) = std::fs::write(&config_path, serialized) {
-                            eprintln!(
-                                "[telemt] Error: failed to create explicit config at {}: {}",
-                                config_path.display(),
-                                write_error
-                            );
-                            std::process::exit(1);
-                        }
-                        eprintln!(
-                            "[telemt] Created default config at {}",
-                            config_path.display()
-                        );
-                    } else {
-                        eprintln!(
-                            "[telemt] Warning: running with in-memory default config without writing to disk"
-                        );
-                    }
-                } else {
-                    let system_dir = std::path::Path::new("/etc/telemt");
-                    let system_config_path = system_dir.join("telemt.toml");
-                    let startup_config_path = startup_cwd.join("config.toml");
-                    let mut persisted = false;
-
-                    if let Some(serialized) = serialized.as_ref() {
-                        match std::fs::create_dir_all(system_dir) {
-                            Ok(()) => match std::fs::write(&system_config_path, serialized) {
-                                Ok(()) => {
-                                    config_path = system_config_path;
-                                    eprintln!(
-                                        "[telemt] Created default config at {}",
-                                        config_path.display()
-                                    );
-                                    persisted = true;
-                                }
-                                Err(write_error) => {
-                                    eprintln!(
-                                        "[telemt] Warning: failed to write default config at {}: {}",
-                                        system_config_path.display(),
-                                        write_error
-                                    );
-                                }
-                            },
-                            Err(create_error) => {
-                                eprintln!(
-                                    "[telemt] Warning: failed to create {}: {}",
-                                    system_dir.display(),
-                                    create_error
-                                );
-                            }
-                        }
-
-                        if !persisted {
-                            match std::fs::write(&startup_config_path, serialized) {
-                                Ok(()) => {
-                                    config_path = startup_config_path;
-                                    eprintln!(
-                                        "[telemt] Created default config at {}",
-                                        config_path.display()
-                                    );
-                                    persisted = true;
-                                }
-                                Err(write_error) => {
-                                    eprintln!(
-                                        "[telemt] Warning: failed to write default config at {}: {}",
-                                        startup_config_path.display(),
-                                        write_error
-                                    );
-                                }
-                            }
-                        }
-                    }
-
-                    if !persisted {
-                        eprintln!(
-                            "[telemt] Warning: running with in-memory default config without writing to disk"
-                        );
-                    }
-                }
-                default
-            }
-        }
-    };
-
-    if let Err(e) = config.validate() {
-        eprintln!("[telemt] Invalid config: {}", e);
-        std::process::exit(1);
-    }
-
-    if let Some(p) = data_path {
-        config.general.data_path = Some(p);
-    }
-
-    if let Some(ref data_path) = config.general.data_path {
-        if !data_path.is_absolute() {
-            eprintln!(
-                "[telemt] data_path must be absolute: {}",
-                data_path.display()
-            );
-            std::process::exit(1);
-        }
-
-        if data_path.exists() {
-            if !data_path.is_dir() {
-                eprintln!(
-                    "[telemt] data_path exists but is not a directory: {}",
-                    data_path.display()
-                );
-                std::process::exit(1);
-            }
-        } else if let Err(e) = std::fs::create_dir_all(data_path) {
-            eprintln!(
-                "[telemt] Can't create data_path {}: {}",
-                data_path.display(),
-                e
-            );
-            std::process::exit(1);
-        }
-
-        if let Err(e) = std::env::set_current_dir(data_path) {
-            eprintln!(
-                "[telemt] Can't use data_path {}: {}",
-                data_path.display(),
-                e
-            );
-            std::process::exit(1);
-        }
-    }
-
-    if let Err(e) = crate::network::dns_overrides::install_entries(&config.network.dns_overrides) {
-        eprintln!("[telemt] Invalid network.dns_overrides: {}", e);
-        std::process::exit(1);
-    }
-    startup_tracker
-        .complete_component(COMPONENT_CONFIG_LOAD, Some("config is ready".to_string()))
-        .await;
-
-    let has_rust_log = std::env::var("RUST_LOG").is_ok();
-    let effective_log_level = if cli_silent {
-        LogLevel::Silent
-    } else if let Some(ref s) = cli_log_level {
-        LogLevel::from_str_loose(s)
-    } else {
-        config.general.log_level.clone()
-    };
-
-    let (filter_layer, filter_handle) = reload::Layer::new(EnvFilter::new("info"));
-    startup_tracker
-        .start_component(
-            COMPONENT_TRACING_INIT,
-            Some("initialize tracing subscriber".to_string()),
-        )
-        .await;
-
-    // Initialize logging based on destination
-    let _logging_guard: Option<crate::logging::LoggingGuard>;
-    match log_destination {
-        crate::logging::LogDestination::Stderr => {
-            // Default: log to stderr (works with systemd journald)
-            let fmt_layer = if config.general.disable_colors {
-                fmt::Layer::default().with_ansi(false)
-            } else {
-                fmt::Layer::default().with_ansi(true)
-            };
-            tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer)
-                .init();
-            _logging_guard = None;
-        }
-        #[cfg(unix)]
-        crate::logging::LogDestination::Syslog => {
-            // Syslog: for OpenRC/FreeBSD
-            let logging_opts = crate::logging::LoggingOptions {
-                destination: log_destination,
-                disable_colors: true,
-            };
-            let (_, guard) = crate::logging::init_logging(&logging_opts, "info");
-            _logging_guard = Some(guard);
-        }
-        crate::logging::LogDestination::File { .. } => {
-            // File logging with optional rotation
-            let logging_opts = crate::logging::LoggingOptions {
-                destination: log_destination,
-                disable_colors: true,
-            };
-            let (_, guard) = crate::logging::init_logging(&logging_opts, "info");
-            _logging_guard = Some(guard);
-        }
-    }
-
-    startup_tracker
-        .complete_component(
-            COMPONENT_TRACING_INIT,
-            Some("tracing initialized".to_string()),
-        )
-        .await;
-
-    info!("Telemt MTProxy v{}", env!("CARGO_PKG_VERSION"));
-    info!("Log level: {}", effective_log_level);
-    if config.general.disable_colors {
-        info!("Colors: disabled");
-    }
-    info!(
-        "Modes: classic={} secure={} tls={}",
-        config.general.modes.classic, config.general.modes.secure, config.general.modes.tls
-    );
-    if config.general.modes.classic {
-        warn!("Classic mode is vulnerable to DPI detection; enable only for legacy clients");
-    }
-    info!("TLS domain: {}", config.censorship.tls_domain);
-    if let Some(ref sock) = config.censorship.mask_unix_sock {
-        info!("Mask: {} -> unix:{}", config.censorship.mask, sock);
-        if !std::path::Path::new(sock).exists() {
-            warn!(
-                "Unix socket '{}' does not exist yet. Masking will fail until it appears.",
-                sock
-            );
-        }
-    } else {
-        info!(
-            "Mask: {} -> {}:{}",
-            config.censorship.mask,
-            config
-                .censorship
-                .mask_host
-                .as_deref()
-                .unwrap_or(&config.censorship.tls_domain),
-            config.censorship.mask_port
-        );
-    }
-
-    if config.censorship.tls_domain == "www.google.com" {
-        warn!("Using default tls_domain. Consider setting a custom domain.");
-    }
-
-    let stats = Arc::new(Stats::new());
-    stats.apply_telemetry_policy(TelemetryPolicy::from_config(&config.general.telemetry));
-
-    let upstream_manager = Arc::new(UpstreamManager::new(
-        config.upstreams.clone(),
-        config.general.upstream_connect_retry_attempts,
-        config.general.upstream_connect_retry_backoff_ms,
-        config.general.upstream_connect_budget_ms,
-        config.general.tg_connect,
-        config.general.upstream_unhealthy_fail_threshold,
-        config.general.upstream_connect_failfast_hard_errors,
-        stats.clone(),
-    ));
-    let ip_tracker = Arc::new(UserIpTracker::new());
-    ip_tracker
-        .load_limits(
-            config.access.user_max_unique_ips_global_each,
-            &config.access.user_max_unique_ips,
-        )
-        .await;
-    ip_tracker
-        .set_limit_policy(
-            config.access.user_max_unique_ips_mode,
-            config.access.user_max_unique_ips_window_secs,
-        )
-        .await;
-    if config.access.user_max_unique_ips_global_each > 0
-        || !config.access.user_max_unique_ips.is_empty()
-    {
-        info!(
-            global_each_limit = config.access.user_max_unique_ips_global_each,
-            explicit_user_limits = config.access.user_max_unique_ips.len(),
-            "User unique IP limits configured"
-        );
-    }
-    if !config.network.dns_overrides.is_empty() {
-        info!(
-            "Runtime DNS overrides configured: {} entries",
-            config.network.dns_overrides.len()
-        );
-    }
-
-    let (api_config_tx, api_config_rx) = watch::channel(Arc::new(config.clone()));
-    let (detected_ips_tx, detected_ips_rx) = watch::channel((None::<IpAddr>, None::<IpAddr>));
-    let initial_admission_open = !config.general.use_middle_proxy;
-    let (admission_tx, admission_rx) = watch::channel(initial_admission_open);
-    let initial_route_mode = if config.general.use_middle_proxy {
-        RelayRouteMode::Middle
-    } else {
-        RelayRouteMode::Direct
-    };
-    let route_runtime = Arc::new(RouteRuntimeController::new(initial_route_mode));
-    let api_me_pool = Arc::new(RwLock::new(None::<Arc<MePool>>));
-    startup_tracker
-        .start_component(
-            COMPONENT_API_BOOTSTRAP,
-            Some("spawn API listener task".to_string()),
-        )
-        .await;
-
-    if config.server.api.enabled {
-        let listen = match config.server.api.listen.parse::<SocketAddr>() {
-            Ok(listen) => listen,
-            Err(error) => {
-                warn!(
-                    error = %error,
-                    listen = %config.server.api.listen,
-                    "Invalid server.api.listen; API is disabled"
-                );
-                SocketAddr::from(([127, 0, 0, 1], 0))
-            }
-        };
-        if listen.port() != 0 {
-            let stats_api = stats.clone();
-            let ip_tracker_api = ip_tracker.clone();
-            let me_pool_api = api_me_pool.clone();
-            let upstream_manager_api = upstream_manager.clone();
-            let route_runtime_api = route_runtime.clone();
-            let config_rx_api = api_config_rx.clone();
-            let admission_rx_api = admission_rx.clone();
-            let config_path_api = config_path.clone();
-            let startup_tracker_api = startup_tracker.clone();
-            let detected_ips_rx_api = detected_ips_rx.clone();
-            tokio::spawn(async move {
-                api::serve(
-                    listen,
-                    stats_api,
-                    ip_tracker_api,
-                    me_pool_api,
-                    route_runtime_api,
-                    upstream_manager_api,
-                    config_rx_api,
-                    admission_rx_api,
-                    config_path_api,
-                    detected_ips_rx_api,
-                    process_started_at_epoch_secs,
-                    startup_tracker_api,
-                )
-                .await;
-            });
-            startup_tracker
-                .complete_component(
-                    COMPONENT_API_BOOTSTRAP,
-                    Some(format!("api task spawned on {}", listen)),
-                )
-                .await;
-        } else {
-            startup_tracker
-                .skip_component(
-                    COMPONENT_API_BOOTSTRAP,
-                    Some("server.api.listen has zero port".to_string()),
-                )
-                .await;
-        }
-    } else {
-        startup_tracker
-            .skip_component(
-                COMPONENT_API_BOOTSTRAP,
-                Some("server.api.enabled is false".to_string()),
-            )
-            .await;
-    }
-
-    let mut tls_domains = Vec::with_capacity(1 + config.censorship.tls_domains.len());
-    tls_domains.push(config.censorship.tls_domain.clone());
-    for d in &config.censorship.tls_domains {
-        if !tls_domains.contains(d) {
-            tls_domains.push(d.clone());
-        }
-    }
-
-    let tls_cache = tls_bootstrap::bootstrap_tls_front(
-        &config,
-        &tls_domains,
-        upstream_manager.clone(),
-        &startup_tracker,
-    )
-    .await;
-
-    startup_tracker
-        .start_component(
-            COMPONENT_NETWORK_PROBE,
-            Some("probe network capabilities".to_string()),
-        )
-        .await;
-    let probe = run_probe(
-        &config.network,
-        &config.upstreams,
-        config.general.middle_proxy_nat_probe,
-        config.general.stun_nat_probe_concurrency,
-    )
-    .await?;
-    detected_ips_tx.send_replace((
-        probe.detected_ipv4.map(IpAddr::V4),
-        probe.detected_ipv6.map(IpAddr::V6),
-    ));
-    let decision =
-        decide_network_capabilities(&config.network, &probe, config.general.middle_proxy_nat_ip);
-    log_probe_result(&probe, &decision);
-    startup_tracker
-        .complete_component(
-            COMPONENT_NETWORK_PROBE,
-            Some("network capabilities determined".to_string()),
-        )
-        .await;
-
-    let prefer_ipv6 = decision.prefer_ipv6();
-    let mut use_middle_proxy = config.general.use_middle_proxy;
-    let beobachten = Arc::new(BeobachtenStore::new());
-    let rng = Arc::new(SecureRandom::new());
-
-    // Connection concurrency limit (0 = unlimited)
-    let max_connections_limit = if config.server.max_connections == 0 {
-        Semaphore::MAX_PERMITS
-    } else {
-        config.server.max_connections as usize
-    };
-    let max_connections = Arc::new(Semaphore::new(max_connections_limit));
-
-    let me2dc_fallback = config.general.me2dc_fallback;
-    let me_init_retry_attempts = config.general.me_init_retry_attempts;
-    if use_middle_proxy && !decision.ipv4_me && !decision.ipv6_me {
-        if me2dc_fallback {
-            warn!("No usable IP family for Middle Proxy detected; falling back to direct DC");
-            use_middle_proxy = false;
-        } else {
-            warn!(
-                "No usable IP family for Middle Proxy detected; me2dc_fallback=false, ME init retries stay active"
-            );
-        }
-    }
-
-    if use_middle_proxy {
-        startup_tracker
-            .set_me_status(StartupMeStatus::Initializing, COMPONENT_ME_SECRET_FETCH)
-            .await;
-        startup_tracker
-            .start_component(
-                COMPONENT_ME_SECRET_FETCH,
-                Some("fetch proxy-secret from source/cache".to_string()),
-            )
-            .await;
-        startup_tracker
-            .set_me_retry_limit(if !me2dc_fallback || me_init_retry_attempts == 0 {
-                "unlimited".to_string()
-            } else {
-                me_init_retry_attempts.to_string()
-            })
-            .await;
-    } else {
-        startup_tracker
-            .set_me_status(StartupMeStatus::Skipped, "skipped")
-            .await;
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_SECRET_FETCH,
-                Some("middle proxy mode disabled".to_string()),
-            )
-            .await;
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_PROXY_CONFIG_V4,
-                Some("middle proxy mode disabled".to_string()),
-            )
-            .await;
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_PROXY_CONFIG_V6,
-                Some("middle proxy mode disabled".to_string()),
-            )
-            .await;
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_POOL_CONSTRUCT,
-                Some("middle proxy mode disabled".to_string()),
-            )
-            .await;
-        startup_tracker
-            .skip_component(
-                COMPONENT_ME_POOL_INIT_STAGE1,
-                Some("middle proxy mode disabled".to_string()),
-            )
-            .await;
-    }
-
-    let me_pool: Option<Arc<MePool>> = me_startup::initialize_me_pool(
-        use_middle_proxy,
-        &config,
-        &decision,
-        &probe,
-        &startup_tracker,
-        upstream_manager.clone(),
-        rng.clone(),
-        stats.clone(),
-        api_me_pool.clone(),
-    )
-    .await;
-
-    // If ME failed to initialize, force direct-only mode.
-    if me_pool.is_some() {
-        startup_tracker.set_transport_mode("middle_proxy").await;
-        startup_tracker.set_degraded(false).await;
-        info!("Transport: Middle-End Proxy - all DC-over-RPC");
-    } else {
-        let _ = use_middle_proxy;
-        use_middle_proxy = false;
-        // Make runtime config reflect direct-only mode for handlers.
-        config.general.use_middle_proxy = false;
-        startup_tracker.set_transport_mode("direct").await;
-        startup_tracker.set_degraded(true).await;
-        if me2dc_fallback {
-            startup_tracker
-                .set_me_status(StartupMeStatus::Failed, "fallback_to_direct")
-                .await;
-        } else {
-            startup_tracker
-                .set_me_status(StartupMeStatus::Skipped, "skipped")
-                .await;
-        }
-        info!("Transport: Direct DC - TCP - standard DC-over-TCP");
-    }
-
-    // Freeze config after possible fallback decision
-    let config = Arc::new(config);
-
-    let replay_checker = Arc::new(ReplayChecker::new(
-        config.access.replay_check_len,
-        Duration::from_secs(config.access.replay_window_secs),
-    ));
-
-    let buffer_pool = Arc::new(BufferPool::with_config(64 * 1024, 4096));
-
-    connectivity::run_startup_connectivity(
-        &config,
-        &me_pool,
-        rng.clone(),
-        &startup_tracker,
-        upstream_manager.clone(),
-        prefer_ipv6,
-        &decision,
-        process_started_at,
-        api_me_pool.clone(),
-    )
-    .await;
-
-    let runtime_watches = runtime_tasks::spawn_runtime_tasks(
-        &config,
-        &config_path,
-        &probe,
-        prefer_ipv6,
-        decision.ipv4_dc,
-        decision.ipv6_dc,
-        &startup_tracker,
-        stats.clone(),
-        upstream_manager.clone(),
-        replay_checker.clone(),
-        me_pool.clone(),
-        rng.clone(),
-        ip_tracker.clone(),
-        beobachten.clone(),
-        api_config_tx.clone(),
-        me_pool.clone(),
-    )
-    .await;
-    let config_rx = runtime_watches.config_rx;
-    let log_level_rx = runtime_watches.log_level_rx;
-    let detected_ip_v4 = runtime_watches.detected_ip_v4;
-    let detected_ip_v6 = runtime_watches.detected_ip_v6;
-
-    admission::configure_admission_gate(
-        &config,
-        me_pool.clone(),
-        route_runtime.clone(),
-        &admission_tx,
-        config_rx.clone(),
-    )
-    .await;
-    let _admission_tx_hold = admission_tx;
-    let shared_state = ProxySharedState::new();
-    conntrack_control::spawn_conntrack_controller(
-        config_rx.clone(),
-        stats.clone(),
-        shared_state.clone(),
-    );
-
-    let bound = listeners::bind_listeners(
-        &config,
-        decision.ipv4_dc,
-        decision.ipv6_dc,
-        detected_ip_v4,
-        detected_ip_v6,
-        &startup_tracker,
-        config_rx.clone(),
-        admission_rx.clone(),
-        stats.clone(),
-        upstream_manager.clone(),
-        replay_checker.clone(),
-        buffer_pool.clone(),
-        rng.clone(),
-        me_pool.clone(),
-        route_runtime.clone(),
-        tls_cache.clone(),
-        ip_tracker.clone(),
-        beobachten.clone(),
-        shared_state.clone(),
-        max_connections.clone(),
-    )
-    .await?;
-    let listeners = bound.listeners;
-    let has_unix_listener = bound.has_unix_listener;
-
-    if listeners.is_empty() && !has_unix_listener {
-        error!("No listeners. Exiting.");
-        std::process::exit(1);
-    }
-
-    // Drop privileges after binding sockets (which may require root for port < 1024)
-    if daemon_opts.user.is_some() || daemon_opts.group.is_some() {
-        if let Err(e) = drop_privileges(daemon_opts.user.as_deref(), daemon_opts.group.as_deref()) {
-            error!(error = %e, "Failed to drop privileges");
-            std::process::exit(1);
-        }
-    }
-
-    runtime_tasks::apply_runtime_log_filter(
-        has_rust_log,
-        &effective_log_level,
-        filter_handle,
-        log_level_rx,
-    )
-    .await;
-
-    runtime_tasks::spawn_metrics_if_configured(
-        &config,
-        &startup_tracker,
-        stats.clone(),
-        beobachten.clone(),
-        ip_tracker.clone(),
-        config_rx.clone(),
-    )
-    .await;
-
-    runtime_tasks::mark_runtime_ready(&startup_tracker).await;
-
-    // Spawn signal handlers for SIGUSR1/SIGUSR2 (non-shutdown signals)
-    shutdown::spawn_signal_handlers(stats.clone(), process_started_at);
-
-    listeners::spawn_tcp_accept_loops(
-        listeners,
-        config_rx.clone(),
-        admission_rx.clone(),
-        stats.clone(),
-        upstream_manager.clone(),
-        replay_checker.clone(),
-        buffer_pool.clone(),
-        rng.clone(),
-        me_pool.clone(),
-        route_runtime.clone(),
-        tls_cache.clone(),
-        ip_tracker.clone(),
-        beobachten.clone(),
-        shared_state,
-        max_connections.clone(),
-    );
-
-    shutdown::wait_for_shutdown(process_started_at, me_pool, stats).await;
-
-    Ok(())
-}

src/maestro/runtime_tasks.rs

@@ -1,364 +0,0 @@
-use std::net::IpAddr;
-use std::path::Path;
-use std::sync::Arc;
-
-use tokio::sync::{mpsc, watch};
-use tracing::{debug, warn};
-use tracing_subscriber::EnvFilter;
-use tracing_subscriber::reload;
-
-use crate::config::hot_reload::spawn_config_watcher;
-use crate::config::{LogLevel, ProxyConfig};
-use crate::crypto::SecureRandom;
-use crate::ip_tracker::UserIpTracker;
-use crate::metrics;
-use crate::network::probe::NetworkProbe;
-use crate::startup::{
-    COMPONENT_CONFIG_WATCHER_START, COMPONENT_METRICS_START, COMPONENT_RUNTIME_READY,
-    StartupTracker,
-};
-use crate::stats::beobachten::BeobachtenStore;
-use crate::stats::telemetry::TelemetryPolicy;
-use crate::stats::{ReplayChecker, Stats};
-use crate::transport::UpstreamManager;
-use crate::transport::middle_proxy::{MePool, MeReinitTrigger};
-
-use super::helpers::write_beobachten_snapshot;
-
-pub(crate) struct RuntimeWatches {
-    pub(crate) config_rx: watch::Receiver<Arc<ProxyConfig>>,
-    pub(crate) log_level_rx: watch::Receiver<LogLevel>,
-    pub(crate) detected_ip_v4: Option<IpAddr>,
-    pub(crate) detected_ip_v6: Option<IpAddr>,
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) async fn spawn_runtime_tasks(
-    config: &Arc<ProxyConfig>,
-    config_path: &Path,
-    probe: &NetworkProbe,
-    prefer_ipv6: bool,
-    decision_ipv4_dc: bool,
-    decision_ipv6_dc: bool,
-    startup_tracker: &Arc<StartupTracker>,
-    stats: Arc<Stats>,
-    upstream_manager: Arc<UpstreamManager>,
-    replay_checker: Arc<ReplayChecker>,
-    me_pool: Option<Arc<MePool>>,
-    rng: Arc<SecureRandom>,
-    ip_tracker: Arc<UserIpTracker>,
-    beobachten: Arc<BeobachtenStore>,
-    api_config_tx: watch::Sender<Arc<ProxyConfig>>,
-    me_pool_for_policy: Option<Arc<MePool>>,
-) -> RuntimeWatches {
-    let um_clone = upstream_manager.clone();
-    let dc_overrides_for_health = config.dc_overrides.clone();
-    tokio::spawn(async move {
-        um_clone
-            .run_health_checks(
-                prefer_ipv6,
-                decision_ipv4_dc,
-                decision_ipv6_dc,
-                dc_overrides_for_health,
-            )
-            .await;
-    });
-
-    let rc_clone = replay_checker.clone();
-    tokio::spawn(async move {
-        rc_clone.run_periodic_cleanup().await;
-    });
-
-    let detected_ip_v4: Option<IpAddr> = probe.detected_ipv4.map(IpAddr::V4);
-    let detected_ip_v6: Option<IpAddr> = probe.detected_ipv6.map(IpAddr::V6);
-    debug!(
-        "Detected IPs: v4={:?} v6={:?}",
-        detected_ip_v4, detected_ip_v6
-    );
-
-    startup_tracker
-        .start_component(
-            COMPONENT_CONFIG_WATCHER_START,
-            Some("spawn config hot-reload watcher".to_string()),
-        )
-        .await;
-    let (config_rx, log_level_rx): (watch::Receiver<Arc<ProxyConfig>>, watch::Receiver<LogLevel>) =
-        spawn_config_watcher(
-            config_path.to_path_buf(),
-            config.clone(),
-            detected_ip_v4,
-            detected_ip_v6,
-        );
-    startup_tracker
-        .complete_component(
-            COMPONENT_CONFIG_WATCHER_START,
-            Some("config hot-reload watcher started".to_string()),
-        )
-        .await;
-    let mut config_rx_api_bridge = config_rx.clone();
-    let api_config_tx_bridge = api_config_tx.clone();
-    tokio::spawn(async move {
-        loop {
-            if config_rx_api_bridge.changed().await.is_err() {
-                break;
-            }
-            let cfg = config_rx_api_bridge.borrow_and_update().clone();
-            api_config_tx_bridge.send_replace(cfg);
-        }
-    });
-
-    let stats_policy = stats.clone();
-    let mut config_rx_policy = config_rx.clone();
-    tokio::spawn(async move {
-        loop {
-            if config_rx_policy.changed().await.is_err() {
-                break;
-            }
-            let cfg = config_rx_policy.borrow_and_update().clone();
-            stats_policy
-                .apply_telemetry_policy(TelemetryPolicy::from_config(&cfg.general.telemetry));
-            if let Some(pool) = &me_pool_for_policy {
-                pool.update_runtime_transport_policy(
-                    cfg.general.me_socks_kdf_policy,
-                    cfg.general.me_route_backpressure_base_timeout_ms,
-                    cfg.general.me_route_backpressure_high_timeout_ms,
-                    cfg.general.me_route_backpressure_high_watermark_pct,
-                    cfg.general.me_reader_route_data_wait_ms,
-                );
-            }
-        }
-    });
-
-    let ip_tracker_policy = ip_tracker.clone();
-    let mut config_rx_ip_limits = config_rx.clone();
-    tokio::spawn(async move {
-        let mut prev_limits = config_rx_ip_limits
-            .borrow()
-            .access
-            .user_max_unique_ips
-            .clone();
-        let mut prev_global_each = config_rx_ip_limits
-            .borrow()
-            .access
-            .user_max_unique_ips_global_each;
-        let mut prev_mode = config_rx_ip_limits.borrow().access.user_max_unique_ips_mode;
-        let mut prev_window = config_rx_ip_limits
-            .borrow()
-            .access
-            .user_max_unique_ips_window_secs;
-
-        loop {
-            if config_rx_ip_limits.changed().await.is_err() {
-                break;
-            }
-            let cfg = config_rx_ip_limits.borrow_and_update().clone();
-
-            if prev_limits != cfg.access.user_max_unique_ips
-                || prev_global_each != cfg.access.user_max_unique_ips_global_each
-            {
-                ip_tracker_policy
-                    .load_limits(
-                        cfg.access.user_max_unique_ips_global_each,
-                        &cfg.access.user_max_unique_ips,
-                    )
-                    .await;
-                prev_limits = cfg.access.user_max_unique_ips.clone();
-                prev_global_each = cfg.access.user_max_unique_ips_global_each;
-            }
-
-            if prev_mode != cfg.access.user_max_unique_ips_mode
-                || prev_window != cfg.access.user_max_unique_ips_window_secs
-            {
-                ip_tracker_policy
-                    .set_limit_policy(
-                        cfg.access.user_max_unique_ips_mode,
-                        cfg.access.user_max_unique_ips_window_secs,
-                    )
-                    .await;
-                prev_mode = cfg.access.user_max_unique_ips_mode;
-                prev_window = cfg.access.user_max_unique_ips_window_secs;
-            }
-        }
-    });
-
-    let beobachten_writer = beobachten.clone();
-    let config_rx_beobachten = config_rx.clone();
-    tokio::spawn(async move {
-        loop {
-            let cfg = config_rx_beobachten.borrow().clone();
-            let sleep_secs = cfg.general.beobachten_flush_secs.max(1);
-
-            if cfg.general.beobachten {
-                let ttl = std::time::Duration::from_secs(
-                    cfg.general.beobachten_minutes.saturating_mul(60),
-                );
-                let path = cfg.general.beobachten_file.clone();
-                let snapshot = beobachten_writer.snapshot_text(ttl);
-                if let Err(e) = write_beobachten_snapshot(&path, &snapshot).await {
-                    warn!(error = %e, path = %path, "Failed to flush beobachten snapshot");
-                }
-            }
-
-            tokio::time::sleep(std::time::Duration::from_secs(sleep_secs)).await;
-        }
-    });
-
-    if let Some(pool) = me_pool {
-        let reinit_trigger_capacity = config.general.me_reinit_trigger_channel.max(1);
-        let (reinit_tx, reinit_rx) = mpsc::channel::<MeReinitTrigger>(reinit_trigger_capacity);
-
-        let pool_clone_sched = pool.clone();
-        let rng_clone_sched = rng.clone();
-        let config_rx_clone_sched = config_rx.clone();
-        tokio::spawn(async move {
-            crate::transport::middle_proxy::me_reinit_scheduler(
-                pool_clone_sched,
-                rng_clone_sched,
-                config_rx_clone_sched,
-                reinit_rx,
-            )
-            .await;
-        });
-
-        let pool_clone = pool.clone();
-        let config_rx_clone = config_rx.clone();
-        let reinit_tx_updater = reinit_tx.clone();
-        tokio::spawn(async move {
-            crate::transport::middle_proxy::me_config_updater(
-                pool_clone,
-                config_rx_clone,
-                reinit_tx_updater,
-            )
-            .await;
-        });
-
-        let config_rx_clone_rot = config_rx.clone();
-        let reinit_tx_rotation = reinit_tx.clone();
-        tokio::spawn(async move {
-            crate::transport::middle_proxy::me_rotation_task(
-                config_rx_clone_rot,
-                reinit_tx_rotation,
-            )
-            .await;
-        });
-    }
-
-    RuntimeWatches {
-        config_rx,
-        log_level_rx,
-        detected_ip_v4,
-        detected_ip_v6,
-    }
-}
-
-pub(crate) async fn apply_runtime_log_filter(
-    has_rust_log: bool,
-    effective_log_level: &LogLevel,
-    filter_handle: reload::Handle<EnvFilter, tracing_subscriber::Registry>,
-    mut log_level_rx: watch::Receiver<LogLevel>,
-) {
-    let runtime_filter = if has_rust_log {
-        EnvFilter::from_default_env()
-    } else if matches!(effective_log_level, LogLevel::Silent) {
-        EnvFilter::new("warn,telemt::links=info")
-    } else {
-        EnvFilter::new(effective_log_level.to_filter_str())
-    };
-    filter_handle
-        .reload(runtime_filter)
-        .expect("Failed to switch log filter");
-
-    tokio::spawn(async move {
-        loop {
-            if log_level_rx.changed().await.is_err() {
-                break;
-            }
-            let level = log_level_rx.borrow_and_update().clone();
-            let new_filter = tracing_subscriber::EnvFilter::new(level.to_filter_str());
-            if let Err(e) = filter_handle.reload(new_filter) {
-                tracing::error!("config reload: failed to update log filter: {}", e);
-            }
-        }
-    });
-}
-
-pub(crate) async fn spawn_metrics_if_configured(
-    config: &Arc<ProxyConfig>,
-    startup_tracker: &Arc<StartupTracker>,
-    stats: Arc<Stats>,
-    beobachten: Arc<BeobachtenStore>,
-    ip_tracker: Arc<UserIpTracker>,
-    config_rx: watch::Receiver<Arc<ProxyConfig>>,
-) {
-    // metrics_listen takes precedence; fall back to metrics_port for backward compat.
-    let metrics_target: Option<(u16, Option<String>)> =
-        if let Some(ref listen) = config.server.metrics_listen {
-            match listen.parse::<std::net::SocketAddr>() {
-                Ok(addr) => Some((addr.port(), Some(listen.clone()))),
-                Err(e) => {
-                    startup_tracker
-                        .skip_component(
-                            COMPONENT_METRICS_START,
-                            Some(format!("invalid metrics_listen \"{}\": {}", listen, e)),
-                        )
-                        .await;
-                    None
-                }
-            }
-        } else {
-            config.server.metrics_port.map(|p| (p, None))
-        };
-
-    if let Some((port, listen)) = metrics_target {
-        let fallback_label = format!("port {}", port);
-        let label = listen.as_deref().unwrap_or(&fallback_label);
-        startup_tracker
-            .start_component(
-                COMPONENT_METRICS_START,
-                Some(format!("spawn metrics endpoint on {}", label)),
-            )
-            .await;
-        let stats = stats.clone();
-        let beobachten = beobachten.clone();
-        let config_rx_metrics = config_rx.clone();
-        let ip_tracker_metrics = ip_tracker.clone();
-        let whitelist = config.server.metrics_whitelist.clone();
-        let listen_backlog = config.server.listen_backlog;
-        tokio::spawn(async move {
-            metrics::serve(
-                port,
-                listen,
-                listen_backlog,
-                stats,
-                beobachten,
-                ip_tracker_metrics,
-                config_rx_metrics,
-                whitelist,
-            )
-            .await;
-        });
-        startup_tracker
-            .complete_component(
-                COMPONENT_METRICS_START,
-                Some("metrics task spawned".to_string()),
-            )
-            .await;
-    } else if config.server.metrics_listen.is_none() {
-        startup_tracker
-            .skip_component(
-                COMPONENT_METRICS_START,
-                Some("server.metrics_port is not configured".to_string()),
-            )
-            .await;
-    }
-}
-
-pub(crate) async fn mark_runtime_ready(startup_tracker: &Arc<StartupTracker>) {
-    startup_tracker
-        .complete_component(
-            COMPONENT_RUNTIME_READY,
-            Some("startup pipeline is fully initialized".to_string()),
-        )
-        .await;
-    startup_tracker.mark_ready().await;
-}

src/maestro/shutdown.rs

@@ -1,206 +0,0 @@
-//! Shutdown and signal handling for telemt.
-//!
-//! Handles graceful shutdown on various signals:
-//! - SIGINT (Ctrl+C) / SIGTERM: Graceful shutdown
-//! - SIGQUIT: Graceful shutdown with stats dump
-//! - SIGUSR1: Reserved for log rotation (logs acknowledgment)
-//! - SIGUSR2: Dump runtime status to log
-//!
-//! SIGHUP is handled separately in config/hot_reload.rs for config reload.
-
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-#[cfg(not(unix))]
-use tokio::signal;
-#[cfg(unix)]
-use tokio::signal::unix::{SignalKind, signal};
-use tracing::{info, warn};
-
-use crate::stats::Stats;
-use crate::transport::middle_proxy::MePool;
-
-use super::helpers::{format_uptime, unit_label};
-
-/// Signal that triggered shutdown.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ShutdownSignal {
-    /// SIGINT (Ctrl+C)
-    Interrupt,
-    /// SIGTERM
-    Terminate,
-    /// SIGQUIT (with stats dump)
-    Quit,
-}
-
-impl std::fmt::Display for ShutdownSignal {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ShutdownSignal::Interrupt => write!(f, "SIGINT"),
-            ShutdownSignal::Terminate => write!(f, "SIGTERM"),
-            ShutdownSignal::Quit => write!(f, "SIGQUIT"),
-        }
-    }
-}
-
-/// Waits for a shutdown signal and performs graceful shutdown.
-pub(crate) async fn wait_for_shutdown(
-    process_started_at: Instant,
-    me_pool: Option<Arc<MePool>>,
-    stats: Arc<Stats>,
-) {
-    let signal = wait_for_shutdown_signal().await;
-    perform_shutdown(signal, process_started_at, me_pool, &stats).await;
-}
-
-/// Waits for any shutdown signal (SIGINT, SIGTERM, SIGQUIT).
-#[cfg(unix)]
-async fn wait_for_shutdown_signal() -> ShutdownSignal {
-    let mut sigint = signal(SignalKind::interrupt()).expect("Failed to register SIGINT handler");
-    let mut sigterm = signal(SignalKind::terminate()).expect("Failed to register SIGTERM handler");
-    let mut sigquit = signal(SignalKind::quit()).expect("Failed to register SIGQUIT handler");
-
-    tokio::select! {
-        _ = sigint.recv() => ShutdownSignal::Interrupt,
-        _ = sigterm.recv() => ShutdownSignal::Terminate,
-        _ = sigquit.recv() => ShutdownSignal::Quit,
-    }
-}
-
-#[cfg(not(unix))]
-async fn wait_for_shutdown_signal() -> ShutdownSignal {
-    signal::ctrl_c().await.expect("Failed to listen for Ctrl+C");
-    ShutdownSignal::Interrupt
-}
-
-/// Performs graceful shutdown sequence.
-async fn perform_shutdown(
-    signal: ShutdownSignal,
-    process_started_at: Instant,
-    me_pool: Option<Arc<MePool>>,
-    stats: &Stats,
-) {
-    let shutdown_started_at = Instant::now();
-    info!(signal = %signal, "Received shutdown signal");
-
-    // Dump stats if SIGQUIT
-    if signal == ShutdownSignal::Quit {
-        dump_stats(stats, process_started_at);
-    }
-
-    info!("Shutting down...");
-    let uptime_secs = process_started_at.elapsed().as_secs();
-    info!("Uptime: {}", format_uptime(uptime_secs));
-
-    // Graceful ME pool shutdown
-    if let Some(pool) = &me_pool {
-        match tokio::time::timeout(Duration::from_secs(2), pool.shutdown_send_close_conn_all())
-            .await
-        {
-            Ok(total) => {
-                info!(
-                    close_conn_sent = total,
-                    "ME shutdown: RPC_CLOSE_CONN broadcast completed"
-                );
-            }
-            Err(_) => {
-                warn!("ME shutdown: RPC_CLOSE_CONN broadcast timed out");
-            }
-        }
-    }
-
-    let shutdown_secs = shutdown_started_at.elapsed().as_secs();
-    info!(
-        "Shutdown completed successfully in {} {}.",
-        shutdown_secs,
-        unit_label(shutdown_secs, "second", "seconds")
-    );
-}
-
-/// Dumps runtime statistics to the log.
-fn dump_stats(stats: &Stats, process_started_at: Instant) {
-    let uptime_secs = process_started_at.elapsed().as_secs();
-
-    info!("=== Runtime Statistics Dump ===");
-    info!("Uptime: {}", format_uptime(uptime_secs));
-
-    // Connection stats
-    info!(
-        "Connections: total={}, current={} (direct={}, me={}), bad={}",
-        stats.get_connects_all(),
-        stats.get_current_connections_total(),
-        stats.get_current_connections_direct(),
-        stats.get_current_connections_me(),
-        stats.get_connects_bad(),
-    );
-
-    // ME pool stats
-    info!(
-        "ME keepalive: sent={}, pong={}, failed={}, timeout={}",
-        stats.get_me_keepalive_sent(),
-        stats.get_me_keepalive_pong(),
-        stats.get_me_keepalive_failed(),
-        stats.get_me_keepalive_timeout(),
-    );
-
-    // Relay stats
-    info!(
-        "Relay idle: soft_mark={}, hard_close={}, pressure_evict={}",
-        stats.get_relay_idle_soft_mark_total(),
-        stats.get_relay_idle_hard_close_total(),
-        stats.get_relay_pressure_evict_total(),
-    );
-
-    info!("=== End Statistics Dump ===");
-}
-
-/// Spawns a background task to handle operational signals (SIGUSR1, SIGUSR2).
-///
-/// These signals don't trigger shutdown but perform specific actions:
-/// - SIGUSR1: Log rotation acknowledgment (for external log rotation tools)
-/// - SIGUSR2: Dump runtime status to log
-#[cfg(unix)]
-pub(crate) fn spawn_signal_handlers(stats: Arc<Stats>, process_started_at: Instant) {
-    tokio::spawn(async move {
-        let mut sigusr1 =
-            signal(SignalKind::user_defined1()).expect("Failed to register SIGUSR1 handler");
-        let mut sigusr2 =
-            signal(SignalKind::user_defined2()).expect("Failed to register SIGUSR2 handler");
-
-        loop {
-            tokio::select! {
-                _ = sigusr1.recv() => {
-                    handle_sigusr1();
-                }
-                _ = sigusr2.recv() => {
-                    handle_sigusr2(&stats, process_started_at);
-                }
-            }
-        }
-    });
-}
-
-/// No-op on non-Unix platforms.
-#[cfg(not(unix))]
-pub(crate) fn spawn_signal_handlers(_stats: Arc<Stats>, _process_started_at: Instant) {
-    // No SIGUSR1/SIGUSR2 on non-Unix
-}
-
-/// Handles SIGUSR1 - log rotation signal.
-///
-/// This signal is typically sent by logrotate or similar tools after
-/// rotating log files. Since tracing-subscriber doesn't natively support
-/// reopening files, we just acknowledge the signal. If file logging is
-/// added in the future, this would reopen log file handles.
-#[cfg(unix)]
-fn handle_sigusr1() {
-    info!("SIGUSR1 received - log rotation acknowledged");
-    // Future: If using file-based logging, reopen file handles here
-}
-
-/// Handles SIGUSR2 - dump runtime status.
-#[cfg(unix)]
-fn handle_sigusr2(stats: &Stats, process_started_at: Instant) {
-    info!("SIGUSR2 received - dumping runtime status");
-    dump_stats(stats, process_started_at);
-}

src/maestro/tls_bootstrap.rs

@@ -1,188 +0,0 @@
-use std::sync::Arc;
-use std::time::Duration;
-
-use rand::RngExt;
-use tracing::warn;
-
-use crate::config::ProxyConfig;
-use crate::startup::{COMPONENT_TLS_FRONT_BOOTSTRAP, StartupTracker};
-use crate::tls_front::TlsFrontCache;
-use crate::tls_front::fetcher::TlsFetchStrategy;
-use crate::transport::UpstreamManager;
-
-pub(crate) async fn bootstrap_tls_front(
-    config: &ProxyConfig,
-    tls_domains: &[String],
-    upstream_manager: Arc<UpstreamManager>,
-    startup_tracker: &Arc<StartupTracker>,
-) -> Option<Arc<TlsFrontCache>> {
-    startup_tracker
-        .start_component(
-            COMPONENT_TLS_FRONT_BOOTSTRAP,
-            Some("initialize TLS front cache/bootstrap tasks".to_string()),
-        )
-        .await;
-
-    let tls_cache: Option<Arc<TlsFrontCache>> = if config.censorship.tls_emulation {
-        let cache = Arc::new(TlsFrontCache::new(
-            tls_domains,
-            config.censorship.fake_cert_len,
-            &config.censorship.tls_front_dir,
-        ));
-        cache.load_from_disk().await;
-
-        let port = config.censorship.mask_port;
-        let proxy_protocol = config.censorship.mask_proxy_protocol;
-        let mask_host = config
-            .censorship
-            .mask_host
-            .clone()
-            .unwrap_or_else(|| config.censorship.tls_domain.clone());
-        let mask_unix_sock = config.censorship.mask_unix_sock.clone();
-        let tls_fetch_scope = (!config.censorship.tls_fetch_scope.is_empty())
-            .then(|| config.censorship.tls_fetch_scope.clone());
-        let tls_fetch = config.censorship.tls_fetch.clone();
-        let fetch_strategy = TlsFetchStrategy {
-            profiles: tls_fetch.profiles,
-            strict_route: tls_fetch.strict_route,
-            attempt_timeout: Duration::from_millis(tls_fetch.attempt_timeout_ms.max(1)),
-            total_budget: Duration::from_millis(tls_fetch.total_budget_ms.max(1)),
-            grease_enabled: tls_fetch.grease_enabled,
-            deterministic: tls_fetch.deterministic,
-            profile_cache_ttl: Duration::from_secs(tls_fetch.profile_cache_ttl_secs),
-        };
-        let fetch_timeout = fetch_strategy.total_budget;
-
-        let cache_initial = cache.clone();
-        let domains_initial = tls_domains.to_vec();
-        let host_initial = mask_host.clone();
-        let unix_sock_initial = mask_unix_sock.clone();
-        let scope_initial = tls_fetch_scope.clone();
-        let upstream_initial = upstream_manager.clone();
-        let strategy_initial = fetch_strategy.clone();
-        tokio::spawn(async move {
-            let mut join = tokio::task::JoinSet::new();
-            for domain in domains_initial {
-                let cache_domain = cache_initial.clone();
-                let host_domain = host_initial.clone();
-                let unix_sock_domain = unix_sock_initial.clone();
-                let scope_domain = scope_initial.clone();
-                let upstream_domain = upstream_initial.clone();
-                let strategy_domain = strategy_initial.clone();
-                join.spawn(async move {
-                    match crate::tls_front::fetcher::fetch_real_tls_with_strategy(
-                        &host_domain,
-                        port,
-                        &domain,
-                        &strategy_domain,
-                        Some(upstream_domain),
-                        scope_domain.as_deref(),
-                        proxy_protocol,
-                        unix_sock_domain.as_deref(),
-                    )
-                    .await
-                    {
-                        Ok(res) => cache_domain.update_from_fetch(&domain, res).await,
-                        Err(e) => {
-                            warn!(domain = %domain, error = %e, "TLS emulation initial fetch failed")
-                        }
-                    }
-                });
-            }
-            while let Some(res) = join.join_next().await {
-                if let Err(e) = res {
-                    warn!(error = %e, "TLS emulation initial fetch task join failed");
-                }
-            }
-        });
-
-        let cache_timeout = cache.clone();
-        let domains_timeout = tls_domains.to_vec();
-        let fake_cert_len = config.censorship.fake_cert_len;
-        tokio::spawn(async move {
-            tokio::time::sleep(fetch_timeout).await;
-            for domain in domains_timeout {
-                let cached = cache_timeout.get(&domain).await;
-                if cached.domain == "default" {
-                    warn!(
-                        domain = %domain,
-                        timeout_secs = fetch_timeout.as_secs(),
-                        fake_cert_len,
-                        "TLS-front fetch not ready within timeout; using cache/default fake cert fallback"
-                    );
-                }
-            }
-        });
-
-        let cache_refresh = cache.clone();
-        let domains_refresh = tls_domains.to_vec();
-        let host_refresh = mask_host.clone();
-        let unix_sock_refresh = mask_unix_sock.clone();
-        let scope_refresh = tls_fetch_scope.clone();
-        let upstream_refresh = upstream_manager.clone();
-        let strategy_refresh = fetch_strategy.clone();
-        tokio::spawn(async move {
-            loop {
-                let base_secs = rand::rng().random_range(4 * 3600..=6 * 3600);
-                let jitter_secs = rand::rng().random_range(0..=7200);
-                tokio::time::sleep(Duration::from_secs(base_secs + jitter_secs)).await;
-
-                let mut join = tokio::task::JoinSet::new();
-                for domain in domains_refresh.clone() {
-                    let cache_domain = cache_refresh.clone();
-                    let host_domain = host_refresh.clone();
-                    let unix_sock_domain = unix_sock_refresh.clone();
-                    let scope_domain = scope_refresh.clone();
-                    let upstream_domain = upstream_refresh.clone();
-                    let strategy_domain = strategy_refresh.clone();
-                    join.spawn(async move {
-                        match crate::tls_front::fetcher::fetch_real_tls_with_strategy(
-                            &host_domain,
-                            port,
-                            &domain,
-                            &strategy_domain,
-                            Some(upstream_domain),
-                            scope_domain.as_deref(),
-                            proxy_protocol,
-                            unix_sock_domain.as_deref(),
-                        )
-                        .await
-                        {
-                            Ok(res) => cache_domain.update_from_fetch(&domain, res).await,
-                            Err(e) => {
-                                warn!(domain = %domain, error = %e, "TLS emulation refresh failed")
-                            }
-                        }
-                    });
-                }
-
-                while let Some(res) = join.join_next().await {
-                    if let Err(e) = res {
-                        warn!(error = %e, "TLS emulation refresh task join failed");
-                    }
-                }
-            }
-        });
-
-        Some(cache)
-    } else {
-        startup_tracker
-            .skip_component(
-                COMPONENT_TLS_FRONT_BOOTSTRAP,
-                Some("censorship.tls_emulation is false".to_string()),
-            )
-            .await;
-        None
-    };
-
-    if tls_cache.is_some() {
-        startup_tracker
-            .complete_component(
-                COMPONENT_TLS_FRONT_BOOTSTRAP,
-                Some("tls front cache is initialized".to_string()),
-            )
-            .await;
-    }
-
-    tls_cache
-}

src/network/dns_overrides.rs

@@ -26,7 +26,9 @@ fn parse_ip_spec(ip_spec: &str) -> Result<IpAddr> {
     }
 
     let ip = ip_spec.parse::<IpAddr>().map_err(|_| {
-        ProxyError::Config(format!("network.dns_overrides IP is invalid: '{ip_spec}'"))
+        ProxyError::Config(format!(
+            "network.dns_overrides IP is invalid: '{ip_spec}'"
+        ))
     })?;
     if matches!(ip, IpAddr::V6(_)) {
         return Err(ProxyError::Config(format!(
@@ -101,9 +103,9 @@ pub fn validate_entries(entries: &[String]) -> Result<()> {
 /// Replace runtime DNS overrides with a new validated snapshot.
 pub fn install_entries(entries: &[String]) -> Result<()> {
     let parsed = parse_entries(entries)?;
-    let mut guard = overrides_store().write().map_err(|_| {
-        ProxyError::Config("network.dns_overrides runtime lock is poisoned".to_string())
-    })?;
+    let mut guard = overrides_store()
+        .write()
+        .map_err(|_| ProxyError::Config("network.dns_overrides runtime lock is poisoned".to_string()))?;
     *guard = parsed;
     Ok(())
 }

src/network/probe.rs

@@ -1,5 +1,4 @@
 #![allow(dead_code)]
-#![allow(clippy::items_after_test_module)]
 
 use std::collections::HashMap;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, UdpSocket};
@@ -9,12 +8,9 @@ use tokio::task::JoinSet;
 use tokio::time::timeout;
 use tracing::{debug, info, warn};
 
-use crate::config::{NetworkConfig, UpstreamConfig, UpstreamType};
+use crate::config::NetworkConfig;
 use crate::error::Result;
-use crate::network::stun::{
-    DualStunResult, IpFamily, StunProbeResult, stun_probe_family_with_bind,
-};
-use crate::transport::UpstreamManager;
+use crate::network::stun::{stun_probe_dual, DualStunResult, IpFamily, StunProbeResult};
 
 #[derive(Debug, Clone, Default)]
 pub struct NetworkProbe {
@@ -61,27 +57,27 @@ const STUN_BATCH_TIMEOUT: Duration = Duration::from_secs(5);
 
 pub async fn run_probe(
     config: &NetworkConfig,
-    upstreams: &[UpstreamConfig],
     nat_probe: bool,
     stun_nat_probe_concurrency: usize,
 ) -> Result<NetworkProbe> {
     let mut probe = NetworkProbe::default();
-    let servers = collect_stun_servers(config);
-    let mut detected_ipv4 = detect_local_ip_v4();
-    let mut detected_ipv6 = detect_local_ip_v6();
-    let mut explicit_detected_ipv4 = false;
-    let mut explicit_detected_ipv6 = false;
-    let mut explicit_reflected_ipv4 = false;
-    let mut explicit_reflected_ipv6 = false;
-    let mut strict_bind_ipv4_requested = false;
-    let mut strict_bind_ipv6_requested = false;
 
-    let global_stun_res = if nat_probe && config.stun_use {
+    probe.detected_ipv4 = detect_local_ip_v4();
+    probe.detected_ipv6 = detect_local_ip_v6();
+
+    probe.ipv4_is_bogon = probe.detected_ipv4.map(is_bogon_v4).unwrap_or(false);
+    probe.ipv6_is_bogon = probe.detected_ipv6.map(is_bogon_v6).unwrap_or(false);
+
+    let stun_res = if nat_probe && config.stun_use {
+        let servers = collect_stun_servers(config);
         if servers.is_empty() {
             warn!("STUN probe is enabled but network.stun_servers is empty");
             DualStunResult::default()
         } else {
-            probe_stun_servers_parallel(&servers, stun_nat_probe_concurrency.max(1), None, None)
+            probe_stun_servers_parallel(
+                &servers,
+                stun_nat_probe_concurrency.max(1),
+            )
             .await
         }
     } else if nat_probe {
@@ -90,119 +86,19 @@ pub async fn run_probe(
     } else {
         DualStunResult::default()
     };
-    let mut reflected_ipv4 = global_stun_res.v4.map(|r| r.reflected_addr);
-    let mut reflected_ipv6 = global_stun_res.v6.map(|r| r.reflected_addr);
-
-    for upstream in upstreams.iter().filter(|upstream| upstream.enabled) {
-        let UpstreamType::Direct {
-            interface,
-            bind_addresses,
-        } = &upstream.upstream_type
-        else {
-            continue;
-        };
-        if let Some(addrs) = bind_addresses.as_ref().filter(|v| !v.is_empty()) {
-            let mut saw_parsed_ip = false;
-            for value in addrs {
-                if let Ok(ip) = value.parse::<IpAddr>() {
-                    saw_parsed_ip = true;
-                    if ip.is_ipv4() {
-                        strict_bind_ipv4_requested = true;
-                    } else {
-                        strict_bind_ipv6_requested = true;
-                    }
-                }
-            }
-            if !saw_parsed_ip {
-                strict_bind_ipv4_requested = true;
-                strict_bind_ipv6_requested = true;
-            }
-        }
-
-        let bind_v4 = UpstreamManager::resolve_bind_address(
-            interface,
-            bind_addresses,
-            SocketAddr::new(IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1)), 443),
-            None,
-            true,
-        );
-        let bind_v6 = UpstreamManager::resolve_bind_address(
-            interface,
-            bind_addresses,
-            SocketAddr::new(
-                IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)),
-                443,
-            ),
-            None,
-            true,
-        );
-
-        if let Some(IpAddr::V4(ip)) = bind_v4
-            && !explicit_detected_ipv4
-        {
-            detected_ipv4 = Some(ip);
-            explicit_detected_ipv4 = true;
-        }
-        if let Some(IpAddr::V6(ip)) = bind_v6
-            && !explicit_detected_ipv6
-        {
-            detected_ipv6 = Some(ip);
-            explicit_detected_ipv6 = true;
-        }
-        if bind_v4.is_none() && bind_v6.is_none() {
-            continue;
-        }
-
-        if !(nat_probe && config.stun_use) || servers.is_empty() {
-            continue;
-        }
-
-        let direct_stun_res = probe_stun_servers_parallel(
-            &servers,
-            stun_nat_probe_concurrency.max(1),
-            bind_v4,
-            bind_v6,
-        )
-        .await;
-        if let Some(reflected) = direct_stun_res.v4.map(|r| r.reflected_addr) {
-            reflected_ipv4 = Some(reflected);
-            explicit_reflected_ipv4 = true;
-        }
-        if let Some(reflected) = direct_stun_res.v6.map(|r| r.reflected_addr) {
-            reflected_ipv6 = Some(reflected);
-            explicit_reflected_ipv6 = true;
-        }
-    }
-
-    if strict_bind_ipv4_requested && !explicit_detected_ipv4 {
-        detected_ipv4 = None;
-        reflected_ipv4 = None;
-    } else if strict_bind_ipv4_requested && !explicit_reflected_ipv4 {
-        reflected_ipv4 = None;
-    }
-    if strict_bind_ipv6_requested && !explicit_detected_ipv6 {
-        detected_ipv6 = None;
-        reflected_ipv6 = None;
-    } else if strict_bind_ipv6_requested && !explicit_reflected_ipv6 {
-        reflected_ipv6 = None;
-    }
-
-    probe.detected_ipv4 = detected_ipv4;
-    probe.detected_ipv6 = detected_ipv6;
-    probe.reflected_ipv4 = reflected_ipv4;
-    probe.reflected_ipv6 = reflected_ipv6;
-    probe.ipv4_is_bogon = probe.detected_ipv4.map(is_bogon_v4).unwrap_or(false);
-    probe.ipv6_is_bogon = probe.detected_ipv6.map(is_bogon_v6).unwrap_or(false);
+    probe.reflected_ipv4 = stun_res.v4.map(|r| r.reflected_addr);
+    probe.reflected_ipv6 = stun_res.v6.map(|r| r.reflected_addr);
 
     // If STUN is blocked but IPv4 is private, try HTTP public-IP fallback.
     if nat_probe
         && probe.reflected_ipv4.is_none()
         && probe.detected_ipv4.map(is_bogon_v4).unwrap_or(false)
-        && let Some(public_ip) = detect_public_ipv4_http(&config.http_ip_detect_urls).await
     {
+        if let Some(public_ip) = detect_public_ipv4_http(&config.http_ip_detect_urls).await {
             probe.reflected_ipv4 = Some(SocketAddr::new(IpAddr::V4(public_ip), 0));
             info!(public_ip = %public_ip, "STUN unavailable, using HTTP public IPv4 fallback");
         }
+    }
 
     probe.ipv4_nat_detected = match (probe.detected_ipv4, probe.reflected_ipv4) {
         (Some(det), Some(reflected)) => det != reflected.ip(),
@@ -215,20 +111,12 @@ pub async fn run_probe(
 
     probe.ipv4_usable = config.ipv4
         && probe.detected_ipv4.is_some()
-        && (!probe.ipv4_is_bogon
-            || probe
-                .reflected_ipv4
-                .map(|r| !is_bogon(r.ip()))
-                .unwrap_or(false));
+        && (!probe.ipv4_is_bogon || probe.reflected_ipv4.map(|r| !is_bogon(r.ip())).unwrap_or(false));
 
     let ipv6_enabled = config.ipv6.unwrap_or(probe.detected_ipv6.is_some());
     probe.ipv6_usable = ipv6_enabled
         && probe.detected_ipv6.is_some()
-        && (!probe.ipv6_is_bogon
-            || probe
-                .reflected_ipv6
-                .map(|r| !is_bogon(r.ip()))
-                .unwrap_or(false));
+        && (!probe.ipv6_is_bogon || probe.reflected_ipv6.map(|r| !is_bogon(r.ip())).unwrap_or(false));
 
     Ok(probe)
 }
@@ -274,8 +162,6 @@ fn collect_stun_servers(config: &NetworkConfig) -> Vec<String> {
 async fn probe_stun_servers_parallel(
     servers: &[String],
     concurrency: usize,
-    bind_v4: Option<IpAddr>,
-    bind_v6: Option<IpAddr>,
 ) -> DualStunResult {
     let mut join_set = JoinSet::new();
     let mut next_idx = 0usize;
@@ -287,12 +173,7 @@ async fn probe_stun_servers_parallel(
             let stun_addr = servers[next_idx].clone();
             next_idx += 1;
             join_set.spawn(async move {
-                let res = timeout(STUN_BATCH_TIMEOUT, async {
-                    let v4 = stun_probe_family_with_bind(&stun_addr, IpFamily::V4, bind_v4).await?;
-                    let v6 = stun_probe_family_with_bind(&stun_addr, IpFamily::V6, bind_v6).await?;
-                    Ok::<DualStunResult, crate::error::ProxyError>(DualStunResult { v4, v6 })
-                })
-                .await;
+                let res = timeout(STUN_BATCH_TIMEOUT, stun_probe_dual(&stun_addr)).await;
                 (stun_addr, res)
             });
         }
@@ -304,15 +185,11 @@ async fn probe_stun_servers_parallel(
         match task {
             Ok((stun_addr, Ok(Ok(result)))) => {
                 if let Some(v4) = result.v4 {
-                    let entry = best_v4_by_ip
-                        .entry(v4.reflected_addr.ip())
-                        .or_insert((0, v4));
+                    let entry = best_v4_by_ip.entry(v4.reflected_addr.ip()).or_insert((0, v4));
                     entry.0 += 1;
                 }
                 if let Some(v6) = result.v6 {
-                    let entry = best_v6_by_ip
-                        .entry(v6.reflected_addr.ip())
-                        .or_insert((0, v6));
+                    let entry = best_v6_by_ip.entry(v6.reflected_addr.ip()).or_insert((0, v6));
                     entry.0 += 1;
                 }
                 if result.v4.is_some() || result.v6.is_some() {
@@ -332,36 +209,35 @@ async fn probe_stun_servers_parallel(
     }
 
     let mut out = DualStunResult::default();
-    if let Some((_, best)) = best_v4_by_ip.into_values().max_by_key(|(count, _)| *count) {
+    if let Some((_, best)) = best_v4_by_ip
+        .into_values()
+        .max_by_key(|(count, _)| *count)
+    {
         info!("STUN-Quorum reached, IP: {}", best.reflected_addr.ip());
         out.v4 = Some(best);
     }
-    if let Some((_, best)) = best_v6_by_ip.into_values().max_by_key(|(count, _)| *count) {
+    if let Some((_, best)) = best_v6_by_ip
+        .into_values()
+        .max_by_key(|(count, _)| *count)
+    {
         info!("STUN-Quorum reached, IP: {}", best.reflected_addr.ip());
         out.v6 = Some(best);
     }
     out
 }
 
-pub fn decide_network_capabilities(
-    config: &NetworkConfig,
-    probe: &NetworkProbe,
-    middle_proxy_nat_ip: Option<IpAddr>,
-) -> NetworkDecision {
+pub fn decide_network_capabilities(config: &NetworkConfig, probe: &NetworkProbe) -> NetworkDecision {
     let ipv4_dc = config.ipv4 && probe.detected_ipv4.is_some();
-    let ipv6_dc =
-        config.ipv6.unwrap_or(probe.detected_ipv6.is_some()) && probe.detected_ipv6.is_some();
-    let nat_ip_v4 = matches!(middle_proxy_nat_ip, Some(IpAddr::V4(_)));
-    let nat_ip_v6 = matches!(middle_proxy_nat_ip, Some(IpAddr::V6(_)));
+    let ipv6_dc = config.ipv6.unwrap_or(probe.detected_ipv6.is_some()) && probe.detected_ipv6.is_some();
 
     let ipv4_me = config.ipv4
         && probe.detected_ipv4.is_some()
-        && (!probe.ipv4_is_bogon || probe.reflected_ipv4.is_some() || nat_ip_v4);
+        && (!probe.ipv4_is_bogon || probe.reflected_ipv4.is_some());
 
     let ipv6_enabled = config.ipv6.unwrap_or(probe.detected_ipv6.is_some());
     let ipv6_me = ipv6_enabled
         && probe.detected_ipv6.is_some()
-        && (!probe.ipv6_is_bogon || probe.reflected_ipv6.is_some() || nat_ip_v6);
+        && (!probe.ipv6_is_bogon || probe.reflected_ipv6.is_some());
 
     let effective_prefer = match config.prefer {
         6 if ipv6_me || ipv6_dc => 6,
@@ -386,58 +262,6 @@ pub fn decide_network_capabilities(
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::config::NetworkConfig;
-
-    #[test]
-    fn manual_nat_ip_enables_ipv4_me_without_reflection() {
-        let config = NetworkConfig {
-            ipv4: true,
-            ..Default::default()
-        };
-        let probe = NetworkProbe {
-            detected_ipv4: Some(Ipv4Addr::new(10, 0, 0, 10)),
-            ipv4_is_bogon: true,
-            ..Default::default()
-        };
-
-        let decision = decide_network_capabilities(
-            &config,
-            &probe,
-            Some(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4))),
-        );
-
-        assert!(decision.ipv4_me);
-    }
-
-    #[test]
-    fn manual_nat_ip_does_not_enable_other_family() {
-        let config = NetworkConfig {
-            ipv4: true,
-            ipv6: Some(true),
-            ..Default::default()
-        };
-        let probe = NetworkProbe {
-            detected_ipv4: Some(Ipv4Addr::new(10, 0, 0, 10)),
-            detected_ipv6: Some(Ipv6Addr::LOCALHOST),
-            ipv4_is_bogon: true,
-            ipv6_is_bogon: true,
-            ..Default::default()
-        };
-
-        let decision = decide_network_capabilities(
-            &config,
-            &probe,
-            Some(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4))),
-        );
-
-        assert!(decision.ipv4_me);
-        assert!(!decision.ipv6_me);
-    }
-}
-
 fn detect_local_ip_v4() -> Option<Ipv4Addr> {
     let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
     socket.connect("8.8.8.8:80").ok()?;
@@ -456,14 +280,6 @@ fn detect_local_ip_v6() -> Option<Ipv6Addr> {
     }
 }
 
-pub fn detect_interface_ipv4() -> Option<Ipv4Addr> {
-    detect_local_ip_v4()
-}
-
-pub fn detect_interface_ipv6() -> Option<Ipv6Addr> {
-    detect_local_ip_v6()
-}
-
 pub fn is_bogon(ip: IpAddr) -> bool {
     match ip {
         IpAddr::V4(v4) => is_bogon_v4(v4),
@@ -537,26 +353,10 @@ pub fn is_bogon_v6(ip: Ipv6Addr) -> bool {
 
 pub fn log_probe_result(probe: &NetworkProbe, decision: &NetworkDecision) {
     info!(
-        ipv4 = probe
-            .detected_ipv4
-            .as_ref()
-            .map(|v| v.to_string())
-            .unwrap_or_else(|| "-".into()),
-        ipv6 = probe
-            .detected_ipv6
-            .as_ref()
-            .map(|v| v.to_string())
-            .unwrap_or_else(|| "-".into()),
-        reflected_v4 = probe
-            .reflected_ipv4
-            .as_ref()
-            .map(|v| v.ip().to_string())
-            .unwrap_or_else(|| "-".into()),
-        reflected_v6 = probe
-            .reflected_ipv6
-            .as_ref()
-            .map(|v| v.ip().to_string())
-            .unwrap_or_else(|| "-".into()),
+        ipv4 = probe.detected_ipv4.as_ref().map(|v| v.to_string()).unwrap_or_else(|| "-".into()),
+        ipv6 = probe.detected_ipv6.as_ref().map(|v| v.to_string()).unwrap_or_else(|| "-".into()),
+        reflected_v4 = probe.reflected_ipv4.as_ref().map(|v| v.ip().to_string()).unwrap_or_else(|| "-".into()),
+        reflected_v6 = probe.reflected_ipv6.as_ref().map(|v| v.ip().to_string()).unwrap_or_else(|| "-".into()),
         ipv4_bogon = probe.ipv4_is_bogon,
         ipv6_bogon = probe.ipv6_is_bogon,
         ipv4_me = decision.ipv4_me,

src/network/stun.rs

@@ -2,20 +2,13 @@
 #![allow(dead_code)]
 
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
-use std::sync::OnceLock;
 
-use tokio::net::{UdpSocket, lookup_host};
-use tokio::time::{Duration, sleep, timeout};
+use tokio::net::{lookup_host, UdpSocket};
+use tokio::time::{timeout, Duration, sleep};
 
-use crate::crypto::SecureRandom;
 use crate::error::{ProxyError, Result};
 use crate::network::dns_overrides::{resolve, split_host_port};
 
-fn stun_rng() -> &'static SecureRandom {
-    static STUN_RNG: OnceLock<SecureRandom> = OnceLock::new();
-    STUN_RNG.get_or_init(SecureRandom::new)
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum IpFamily {
     V4,
@@ -41,13 +34,13 @@ pub async fn stun_probe_dual(stun_addr: &str) -> Result<DualStunResult> {
         stun_probe_family(stun_addr, IpFamily::V6),
     );
 
-    Ok(DualStunResult { v4: v4?, v6: v6? })
+    Ok(DualStunResult {
+        v4: v4?,
+        v6: v6?,
+    })
 }
 
-pub async fn stun_probe_family(
-    stun_addr: &str,
-    family: IpFamily,
-) -> Result<Option<StunProbeResult>> {
+pub async fn stun_probe_family(stun_addr: &str, family: IpFamily) -> Result<Option<StunProbeResult>> {
     stun_probe_family_with_bind(stun_addr, family, None).await
 }
 
@@ -56,6 +49,8 @@ pub async fn stun_probe_family_with_bind(
     family: IpFamily,
     bind_ip: Option<IpAddr>,
 ) -> Result<Option<StunProbeResult>> {
+    use rand::RngCore;
+
     let bind_addr = match (family, bind_ip) {
         (IpFamily::V4, Some(IpAddr::V4(ip))) => SocketAddr::new(IpAddr::V4(ip), 0),
         (IpFamily::V6, Some(IpAddr::V6(ip))) => SocketAddr::new(IpAddr::V6(ip), 0),
@@ -76,18 +71,13 @@ pub async fn stun_probe_family_with_bind(
     if let Some(addr) = target_addr {
         match socket.connect(addr).await {
             Ok(()) => {}
-            Err(e)
-                if family == IpFamily::V6
-                    && matches!(
+            Err(e) if family == IpFamily::V6 && matches!(
                 e.kind(),
                 std::io::ErrorKind::NetworkUnreachable
                 | std::io::ErrorKind::HostUnreachable
                 | std::io::ErrorKind::Unsupported
                 | std::io::ErrorKind::NetworkDown
-                    ) =>
-            {
-                return Ok(None);
-            }
+            ) => return Ok(None),
             Err(e) => return Err(ProxyError::Proxy(format!("STUN connect failed: {e}"))),
         }
     } else {
@@ -98,7 +88,7 @@ pub async fn stun_probe_family_with_bind(
     req[0..2].copy_from_slice(&0x0001u16.to_be_bytes()); // Binding Request
     req[2..4].copy_from_slice(&0u16.to_be_bytes()); // length
     req[4..8].copy_from_slice(&0x2112A442u32.to_be_bytes()); // magic cookie
-    stun_rng().fill(&mut req[8..20]); // transaction ID
+    rand::rng().fill_bytes(&mut req[8..20]); // transaction ID
 
     let mut buf = [0u8; 256];
     let mut attempt = 0;
@@ -210,6 +200,7 @@ pub async fn stun_probe_family_with_bind(
 
         idx += (alen + 3) & !3;
     }
+
     }
 
     Ok(None)
@@ -237,11 +228,7 @@ async fn resolve_stun_addr(stun_addr: &str, family: IpFamily) -> Result<Option<S
         .await
         .map_err(|e| ProxyError::Proxy(format!("STUN resolve failed: {e}")))?;
 
-    let target = addrs.find(|a| {
-        matches!(
-            (a.is_ipv4(), family),
-            (true, IpFamily::V4) | (false, IpFamily::V6)
-        )
-    });
+    let target = addrs
+        .find(|a| matches!((a.is_ipv4(), family), (true, IpFamily::V4) | (false, IpFamily::V6)));
     Ok(target)
 }

src/protocol/constants.rs

@@ -36,86 +36,32 @@ pub static TG_DATACENTERS_V6: LazyLock<Vec<IpAddr>> = LazyLock::new(|| {
 pub static TG_MIDDLE_PROXIES_V4: LazyLock<std::collections::HashMap<i32, Vec<(IpAddr, u16)>>> = 
     LazyLock::new(|| {
         let mut m = std::collections::HashMap::new();
-        m.insert(
-            1,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 50)), 8888)],
-        );
-        m.insert(
-            -1,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 50)), 8888)],
-        );
-        m.insert(
-            2,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 161, 144)), 8888)],
-        );
-        m.insert(
-            -2,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 161, 144)), 8888)],
-        );
-        m.insert(
-            3,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 100)), 8888)],
-        );
-        m.insert(
-            -3,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 100)), 8888)],
-        );
+        m.insert(1, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 50)), 8888)]);
+        m.insert(-1, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 50)), 8888)]);
+        m.insert(2, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 161, 144)), 8888)]);
+        m.insert(-2, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 161, 144)), 8888)]);
+        m.insert(3, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 100)), 8888)]);
+        m.insert(-3, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 175, 100)), 8888)]);
         m.insert(4, vec![(IpAddr::V4(Ipv4Addr::new(91, 108, 4, 136)), 8888)]);
-        m.insert(
-            -4,
-            vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 165, 109)), 8888)],
-        );
+        m.insert(-4, vec![(IpAddr::V4(Ipv4Addr::new(149, 154, 165, 109)), 8888)]);
         m.insert(5, vec![(IpAddr::V4(Ipv4Addr::new(91, 108, 56, 183)), 8888)]);
-        m.insert(
-            -5,
-            vec![(IpAddr::V4(Ipv4Addr::new(91, 108, 56, 183)), 8888)],
-        );
+        m.insert(-5, vec![(IpAddr::V4(Ipv4Addr::new(91, 108, 56, 183)), 8888)]);
         m
     });
 
 pub static TG_MIDDLE_PROXIES_V6: LazyLock<std::collections::HashMap<i32, Vec<(IpAddr, u16)>>> = 
     LazyLock::new(|| {
         let mut m = std::collections::HashMap::new();
-        m.insert(
-            1,
-            vec![(IpAddr::V6("2001:b28:f23d:f001::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            -1,
-            vec![(IpAddr::V6("2001:b28:f23d:f001::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            2,
-            vec![(IpAddr::V6("2001:67c:04e8:f002::d".parse().unwrap()), 80)],
-        );
-        m.insert(
-            -2,
-            vec![(IpAddr::V6("2001:67c:04e8:f002::d".parse().unwrap()), 80)],
-        );
-        m.insert(
-            3,
-            vec![(IpAddr::V6("2001:b28:f23d:f003::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            -3,
-            vec![(IpAddr::V6("2001:b28:f23d:f003::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            4,
-            vec![(IpAddr::V6("2001:67c:04e8:f004::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            -4,
-            vec![(IpAddr::V6("2001:67c:04e8:f004::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            5,
-            vec![(IpAddr::V6("2001:b28:f23f:f005::d".parse().unwrap()), 8888)],
-        );
-        m.insert(
-            -5,
-            vec![(IpAddr::V6("2001:b28:f23f:f005::d".parse().unwrap()), 8888)],
-        );
+        m.insert(1, vec![(IpAddr::V6("2001:b28:f23d:f001::d".parse().unwrap()), 8888)]);
+        m.insert(-1, vec![(IpAddr::V6("2001:b28:f23d:f001::d".parse().unwrap()), 8888)]);
+        m.insert(2, vec![(IpAddr::V6("2001:67c:04e8:f002::d".parse().unwrap()), 80)]);
+        m.insert(-2, vec![(IpAddr::V6("2001:67c:04e8:f002::d".parse().unwrap()), 80)]);
+        m.insert(3, vec![(IpAddr::V6("2001:b28:f23d:f003::d".parse().unwrap()), 8888)]);
+        m.insert(-3, vec![(IpAddr::V6("2001:b28:f23d:f003::d".parse().unwrap()), 8888)]);
+        m.insert(4, vec![(IpAddr::V6("2001:67c:04e8:f004::d".parse().unwrap()), 8888)]);
+        m.insert(-4, vec![(IpAddr::V6("2001:67c:04e8:f004::d".parse().unwrap()), 8888)]);
+        m.insert(5, vec![(IpAddr::V6("2001:b28:f23f:f005::d".parse().unwrap()), 8888)]);
+        m.insert(-5, vec![(IpAddr::V6("2001:b28:f23f:f005::d".parse().unwrap()), 8888)]);
         m
     });
 
@@ -206,29 +152,11 @@ pub const TLS_RECORD_CHANGE_CIPHER: u8 = 0x14;
 pub const TLS_RECORD_APPLICATION: u8 = 0x17;
 /// TLS record type: Alert
 pub const TLS_RECORD_ALERT: u8 = 0x15;
-/// Maximum TLS plaintext record payload size.
-/// RFC 8446 §5.1: "The length MUST NOT exceed 2^14 bytes."
-/// Use this for validating incoming unencrypted records
-/// (ClientHello, ChangeCipherSpec, unprotected Handshake messages).
-pub const MAX_TLS_PLAINTEXT_SIZE: usize = 16_384;
-
-/// Structural minimum for a valid TLS 1.3 ClientHello with SNI.
-/// Derived from RFC 8446 §4.1.2 field layout + Appendix D.4 compat mode.
-/// Deliberately conservative (below any real client) to avoid false
-/// positives on legitimate connections with compact extension sets.
-pub const MIN_TLS_CLIENT_HELLO_SIZE: usize = 100;
-
-/// Maximum TLS ciphertext record payload size.
-/// RFC 8446 §5.2: "The length MUST NOT exceed 2^14 + 256 bytes."
-/// The +256 accounts for maximum AEAD expansion overhead.
-/// Use this for validating or sizing buffers for encrypted records.
-pub const MAX_TLS_CIPHERTEXT_SIZE: usize = 16_384 + 256;
-
-#[deprecated(note = "use MAX_TLS_PLAINTEXT_SIZE")]
-pub const MAX_TLS_RECORD_SIZE: usize = MAX_TLS_PLAINTEXT_SIZE;
-
-#[deprecated(note = "use MAX_TLS_CIPHERTEXT_SIZE")]
-pub const MAX_TLS_CHUNK_SIZE: usize = MAX_TLS_CIPHERTEXT_SIZE;
+/// Maximum TLS record size
+pub const MAX_TLS_RECORD_SIZE: usize = 16384;
+/// Maximum TLS chunk size (with overhead)
+/// RFC 8446 §5.2 allows up to 16384 + 256 bytes of ciphertext
+pub const MAX_TLS_CHUNK_SIZE: usize = 16384 + 256;
 
 /// Secure Intermediate payload is expected to be 4-byte aligned.
 pub fn is_valid_secure_payload_len(data_len: usize) -> bool {
@@ -276,7 +204,9 @@ pub const SMALL_BUFFER_SIZE: usize = 8192;
 // ============= Statistics =============
 
 /// Duration buckets for histogram metrics
-pub static DURATION_BUCKETS: &[f64] = &[0.1, 0.5, 1.0, 2.0, 5.0, 15.0, 60.0, 300.0, 600.0, 1800.0];
+pub static DURATION_BUCKETS: &[f64] = &[
+    0.1, 0.5, 1.0, 2.0, 5.0, 15.0, 60.0, 300.0, 600.0, 1800.0,
+];
 
 // ============= Reserved Nonce Patterns =============
 
@@ -294,7 +224,9 @@ pub static RESERVED_NONCE_BEGINNINGS: &[[u8; 4]] = &[
 ];
 
 /// Reserved continuation bytes (bytes 4-7)
-pub static RESERVED_NONCE_CONTINUES: &[[u8; 4]] = &[[0x00, 0x00, 0x00, 0x00]];
+pub static RESERVED_NONCE_CONTINUES: &[[u8; 4]] = &[
+    [0x00, 0x00, 0x00, 0x00],
+];
 
 // ============= RPC Constants (for Middle Proxy) =============
 
@@ -335,10 +267,11 @@ pub mod rpc_flags {
     pub const FLAG_QUICKACK: u32 = 0x80000000;
 }
 
-// ============= Middle-End Proxy Servers =============
-pub const ME_PROXY_PORT: u16 = 8888;
 
-pub static TG_MIDDLE_PROXIES_FLAT_V4: LazyLock<Vec<(IpAddr, u16)>> = LazyLock::new(|| {
+    // ============= Middle-End Proxy Servers =============
+    pub const ME_PROXY_PORT: u16 = 8888;
+    
+    pub static TG_MIDDLE_PROXIES_FLAT_V4: LazyLock<Vec<(IpAddr, u16)>> = LazyLock::new(|| {
         vec![
             (IpAddr::V4(Ipv4Addr::new(149, 154, 175, 50)), 8888),
             (IpAddr::V4(Ipv4Addr::new(149, 154, 161, 144)), 8888),
@@ -346,29 +279,29 @@ pub static TG_MIDDLE_PROXIES_FLAT_V4: LazyLock<Vec<(IpAddr, u16)>> = LazyLock::n
             (IpAddr::V4(Ipv4Addr::new(91, 108, 4, 136)), 8888),
             (IpAddr::V4(Ipv4Addr::new(91, 108, 56, 183)), 8888),
         ]
-});
+    });
     
-// ============= RPC Constants (u32 native endian) =============
-// From mtproto-common.h + net-tcp-rpc-common.h + mtproto-proxy.c
+    // ============= RPC Constants (u32 native endian) =============
+    // From mtproto-common.h + net-tcp-rpc-common.h + mtproto-proxy.c
     
-pub const RPC_NONCE_U32: u32 = 0x7acb87aa;
-pub const RPC_HANDSHAKE_U32: u32 = 0x7682eef5;
-pub const RPC_HANDSHAKE_ERROR_U32: u32 = 0x6a27beda;
-pub const TL_PROXY_TAG_U32: u32 = 0xdb1e26ae; // mtproto-proxy.c:121
+    pub const RPC_NONCE_U32: u32           = 0x7acb87aa;
+    pub const RPC_HANDSHAKE_U32: u32       = 0x7682eef5;
+    pub const RPC_HANDSHAKE_ERROR_U32: u32 = 0x6a27beda;
+    pub const TL_PROXY_TAG_U32: u32        = 0xdb1e26ae;  // mtproto-proxy.c:121
     
-// mtproto-common.h
-pub const RPC_PROXY_REQ_U32: u32 = 0x36cef1ee;
-pub const RPC_PROXY_ANS_U32: u32 = 0x4403da0d;
-pub const RPC_CLOSE_CONN_U32: u32 = 0x1fcf425d;
-pub const RPC_CLOSE_EXT_U32: u32 = 0x5eb634a2;
-pub const RPC_SIMPLE_ACK_U32: u32 = 0x3bac409b;
-pub const RPC_PING_U32: u32 = 0x5730a2df;
-pub const RPC_PONG_U32: u32 = 0x8430eaa7;
+    // mtproto-common.h
+    pub const RPC_PROXY_REQ_U32: u32       = 0x36cef1ee;
+    pub const RPC_PROXY_ANS_U32: u32       = 0x4403da0d;
+    pub const RPC_CLOSE_CONN_U32: u32      = 0x1fcf425d;
+    pub const RPC_CLOSE_EXT_U32: u32       = 0x5eb634a2;
+    pub const RPC_SIMPLE_ACK_U32: u32      = 0x3bac409b;
+    pub const RPC_PING_U32: u32            = 0x5730a2df;
+    pub const RPC_PONG_U32: u32            = 0x8430eaa7;
     
-pub const RPC_CRYPTO_NONE_U32: u32 = 0;
-pub const RPC_CRYPTO_AES_U32: u32 = 1;
+    pub const RPC_CRYPTO_NONE_U32: u32 = 0;
+    pub const RPC_CRYPTO_AES_U32: u32  = 1;
     
-pub mod proxy_flags {
+    pub mod proxy_flags {
         pub const FLAG_HAS_AD_TAG: u32    = 1;
         pub const FLAG_NOT_ENCRYPTED: u32 = 0x2;
         pub const FLAG_HAS_AD_TAG2: u32   = 0x8;
@@ -378,20 +311,16 @@ pub mod proxy_flags {
         pub const FLAG_INTERMEDIATE: u32  = 0x20000000;
         pub const FLAG_ABRIDGED: u32      = 0x40000000;
         pub const FLAG_QUICKACK: u32      = 0x80000000;
-}
+    }
 
-pub mod rpc_crypto_flags {
+    pub mod rpc_crypto_flags {
         pub const USE_CRC32C: u32 = 0x800;
-}
+    }
     
-pub const ME_CONNECT_TIMEOUT_SECS: u64 = 5;
-pub const ME_HANDSHAKE_TIMEOUT_SECS: u64 = 10;
+    pub const ME_CONNECT_TIMEOUT_SECS: u64 = 5;
+    pub const ME_HANDSHAKE_TIMEOUT_SECS: u64 = 10;
     
-#[cfg(test)]
-#[path = "tests/tls_size_constants_security_tests.rs"]
-mod tls_size_constants_security_tests;
-
-#[cfg(test)]
+    #[cfg(test)]
 mod tests {
     use super::*;
     

src/protocol/frame.rs

@@ -83,7 +83,7 @@ impl FrameMode {
 
 /// Validate message length for MTProto
 pub fn validate_message_length(len: usize) -> bool {
-    use super::constants::{MAX_MSG_LEN, MIN_MSG_LEN, PADDING_FILLER};
+    use super::constants::{MIN_MSG_LEN, MAX_MSG_LEN, PADDING_FILLER};
     
     (MIN_MSG_LEN..=MAX_MSG_LEN).contains(&len) && len.is_multiple_of(PADDING_FILLER.len())
 }

src/protocol/obfuscation.rs

@@ -2,9 +2,9 @@
 
 #![allow(dead_code)]
 
-use super::constants::*;
-use crate::crypto::{AesCtr, sha256};
 use zeroize::Zeroize;
+use crate::crypto::{sha256, AesCtr};
+use super::constants::*;
 
 /// Obfuscation parameters from handshake
 ///
@@ -69,8 +69,9 @@ impl ObfuscationParams {
                 None => continue,
             };
             
-            let dc_idx =
-                i16::from_le_bytes(decrypted[DC_IDX_POS..DC_IDX_POS + 2].try_into().unwrap());
+            let dc_idx = i16::from_le_bytes(
+                decrypted[DC_IDX_POS..DC_IDX_POS + 2].try_into().unwrap()
+            );
             
             let mut enc_key_input = Vec::with_capacity(PREKEY_LEN + secret.len());
             enc_key_input.extend_from_slice(enc_prekey);