release: bump version to 0.37.0

release: bump version to 0.36.0
release: bump version to 0.35.1
2026-04-23 07:56:10 +08:00 · 2026-04-22 23:42:10 +08:00 · 2026-04-22 18:04:54 +08:00 · 2026-04-22 17:37:00 +08:00 · 2026-04-22 17:29:24 +08:00
45 changed files with 6389 additions and 419 deletions
--- a/.claude/commands/goal-driven.md
+++ b/.claude/commands/goal-driven.md
@@ -0,0 +1,91 @@
+---
+description: 用 goal-driven 方法推动一个复杂任务持续执行，直到明确成功标准被满足
+argument-hint: 建议填写任务目标；若同时给出成功标准更好
+allowed-tools: ["Read", "Edit", "Bash", "Grep", "Glob"]
+---
+
+# /goal-driven — 目标驱动执行模式
+
+使用 `lidangzzz/goal-driven` 的核心思想来推进复杂任务：先固定目标与成功标准，再持续执行和反复验收，直到标准真正满足。
+
+适用场景：
+
+- 长周期实现任务
+- 高复杂度工程任务
+- 可被明确验收的研究、实现、迁移、验证类工作
+
+不适用场景：
+
+- 纯脑暴
+- 无法定义成功标准的模糊任务
+- 很小的一次性修改
+
+## 输入要求
+
+若 `$ARGUMENTS` 只包含目标，没有成功标准，先补全一版可执行的成功标准再开始。
+
+启动时先输出：
+
+```md
+Goal
+- ...
+
+Criteria for success
+- ...
+
+Plan
+1. ...
+2. ...
+3. ...
+
+Verification
+- ...
+```
+
+## 执行规则
+
+1. 先把任务固化为两个核心块：
+   - `Goal`
+   - `Criteria for success`
+
+2. 成功标准必须尽量客观，可验证，可落地。
+   优先写成：
+   - 需要交付什么
+   - 需要通过哪些测试或验证
+   - 如何判断结果真的完成
+
+3. 进入持续执行循环：
+   - 完成一个阶段
+   - 检查当前结果是否满足成功标准
+   - 若未满足，明确剩余差距并继续推进
+
+4. 任何“完成了”“差不多了”“已实现”之类的结论，都必须经过验证，不能直接接受。
+
+5. 如果验证失败：
+   - 明确指出哪条成功标准没满足
+   - 继续工作，不要把阶段性进展误判为完成
+
+6. 只有在以下情况之一才能停止：
+   - 成功标准已满足
+   - 用户明确要求停止
+
+## 执行风格
+
+- 重证据，轻口头判断
+- 重验收，轻自我感觉
+- 优先用测试、日志、产物、对比结果来证明完成
+- 对长期任务保持“未达标就继续”的节奏
+
+## 简版模板
+
+```md
+Goal: [[[[[在此填写最终目标]]]]]
+
+Criteria for success: [[[[[在此填写成功标准]]]]]
+
+循环执行：
+1. 推进任务
+2. 检查是否满足成功标准
+3. 若未满足，继续工作
+4. 直到满足标准或用户明确停止
+```
--- a/.codex/config.toml
+++ b/.codex/config.toml
@@ -0,0 +1,3 @@
+approval_policy = "never"
+
+sandbox_mode = "danger-full-access"
--- a/.codex/skills/goal-driven/SKILL.md
+++ b/.codex/skills/goal-driven/SKILL.md
@@ -0,0 +1,101 @@
+---
+name: goal-driven
+description: Run a goal-driven execution loop for very large, long-horizon, rigorously verifiable tasks. Use when the user explicitly wants the lidangzzz/goal-driven method, a master-agent plus worker-agent style workflow, or a persistent loop that keeps working until concrete success criteria are satisfied.
+---
+
+# Goal-Driven
+
+Use this skill when the user wants a strict goal-driven workflow for a hard task with:
+
+- one clear end goal
+- explicit success criteria
+- repeated verification against those criteria
+- continued execution until the criteria are actually met
+
+This skill is adapted from `lidangzzz/goal-driven`, but trimmed for local skill use to avoid bloating context.
+
+## When To Use
+
+Use it for tasks like:
+
+- compilers, interpreters, theorem-like proof work, deep refactors
+- long-running system design or implementation work
+- problems that are expensive and complex, but still objectively testable
+
+Do not use it for:
+
+- vague brainstorming without a success condition
+- short one-shot edits
+- tasks where "done" cannot be evaluated in a meaningful way
+
+## Core Model
+
+The workflow has two roles:
+
+1. Master role
+   Defines the goal, defines the success criteria, audits progress, and decides whether the work is actually complete.
+
+2. Worker role
+   Keeps advancing the task toward the goal. If a result is partial, stalled, or unverifiable, the worker continues.
+
+In Codex, only use actual subagents when the user explicitly asks for delegation or subagent work and the platform supports it. Otherwise emulate the same loop locally: keep working, checkpointing, and re-verifying until the criteria are satisfied.
+
+## Workflow
+
+1. Normalize the task into two blocks:
+   - `Goal`
+   - `Criteria for success`
+
+2. Make the criteria concrete and testable.
+   Good criteria usually include:
+   - required outputs
+   - required validations or tests
+   - edge cases or coverage thresholds
+   - what evidence proves completion
+
+3. Break the work into milestones that can each produce evidence.
+
+4. Execute the next milestone.
+   If subagents are explicitly allowed, the master may delegate bounded worker tasks.
+   If not, do the work locally but keep the master/worker mindset.
+
+5. Whenever work pauses, stalls, or appears complete, audit against the criteria directly.
+   Check artifacts, tests, logs, diffs, metrics, or other real evidence.
+
+6. If the criteria are not met, continue with a specific delta:
+   - what is still missing
+   - what evidence failed
+   - what the next worker pass must improve
+
+7. Stop only when the criteria are met, or when the user explicitly stops the process.
+
+## Operating Rules
+
+- Prefer objective checks over self-reported completion.
+- Do not confuse progress with completion.
+- If the worker says "done", verify it.
+- If verification fails, continue from the gap instead of restarting blindly.
+- Keep the goal stable unless the user changes it.
+- Tighten fuzzy criteria before sinking large amounts of effort.
+
+## Recommended Response Shape
+
+When starting a goal-driven task, structure the kickoff like this:
+
+```md
+Goal
+- ...
+
+Criteria for success
+- ...
+
+Current plan
+1. ...
+2. ...
+3. ...
+
+Verification
+- What evidence will prove completion
+```
+
+For a reusable prompt template, read [references/prompt-template.md](references/prompt-template.md).
--- a/.codex/skills/goal-driven/agents/openai.yaml
+++ b/.codex/skills/goal-driven/agents/openai.yaml
@@ -0,0 +1,7 @@
+interface:
+  display_name: "Goal-Driven"
+  short_description: "Drive complex work until explicit success criteria are met."
+  default_prompt: "Use $goal-driven to turn this task into a concrete goal, explicit success criteria, and a verification-driven execution loop."
+
+policy:
+  allow_implicit_invocation: true
--- a/.codex/skills/goal-driven/references/prompt-template.md
+++ b/.codex/skills/goal-driven/references/prompt-template.md
@@ -0,0 +1,38 @@
+# Goal-Driven Prompt Template
+
+Use this when you want a reusable kickoff prompt for a master/worker execution loop.
+
+```md
+# Goal-Driven System
+
+Goal: [[[[[DEFINE THE FINAL GOAL HERE]]]]]
+
+Criteria for success: [[[[[DEFINE THE SUCCESS CRITERIA HERE]]]]]
+
+You are the master agent.
+
+Your job is to:
+1. Keep the goal and criteria fixed.
+2. Start worker execution toward the goal.
+3. Audit any claimed progress against the criteria.
+4. If the criteria are not met, continue the work with a precise next delta.
+5. Stop only when the criteria are satisfied or the user explicitly stops the process.
+
+Worker requirements:
+1. Break the task into subproblems.
+2. Keep producing concrete progress toward the goal.
+3. Report evidence, not just claims.
+4. Continue until the criteria are satisfied.
+
+Master audit loop:
+1. Check whether the worker is still making progress.
+2. If the worker stalls or claims completion, verify against the criteria.
+3. If verification fails, resume work from the remaining gap.
+4. Repeat until the criteria are met.
+```
+
+## Notes
+
+- Stronger criteria produce better results than stronger rhetoric.
+- Prefer measurable checks such as tests, parity checks, generated artifacts, benchmarks, or reviewable outputs.
+- If the environment does not support subagents, emulate the same loop locally.
--- a/README.md
+++ b/README.md
@@ -227,6 +227,120 @@ bun run build

 启动服务后访问: `http://localhost:8000/docs`

+## WSL / Windows 局域网访问
+
+如果服务运行在 WSL 中，而你希望：
+
+- Windows 本机浏览器访问开发服务
+- 同一局域网内的手机或其他电脑访问开发服务
+
+推荐按下面顺序排查和配置。
+
+### 1. 在 WSL 中启动服务
+
+```bash
+./planet.sh start --allow-lan
+```
+
+这会让前端监听 `0.0.0.0:3000`，后端监听 `0.0.0.0:8000`。
+
+### 2. 先确认 WSL 内部服务正常
+
+在 WSL 中执行：
+
+```bash
+curl http://localhost:3000
+curl http://localhost:8000/health
+ss -ltnp | grep -E ':3000|:8000'
+```
+
+预期：
+
+- `3000` 返回前端 HTML
+- `8000/health` 返回健康检查 JSON
+- `ss` 中能看到 `0.0.0.0:3000` 和 `0.0.0.0:8000`
+
+如果这一步不通，先不要继续做 Windows 转发。
+
+### 3. 在 Windows 本机验证 localhost 直通
+
+在 Windows PowerShell 中执行：
+
+```powershell
+curl http://localhost:3000
+curl http://localhost:8000/health
+```
+
+在常见的 WSL2 开发环境下，Windows 通常可以直接通过 `localhost` 访问 WSL 中的服务。
+
+### 4. 如果需要让局域网设备访问，再做 Windows 端口转发
+
+注意：下面的命令必须在“以管理员身份运行”的 PowerShell 中执行。
+
+先把 Windows 对外网卡上的 `3000` / `8000` 转发到 Windows 本机 `127.0.0.1`：
+
+```powershell
+netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=3000
+netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=8000
+
+netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=3000 connectaddress=127.0.0.1 connectport=3000
+netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=8000 connectaddress=127.0.0.1 connectport=8000
+```
+
+再放行 Windows 防火墙：
+
+```powershell
+New-NetFirewallRule -DisplayName "WSL Planet 3000" -Direction Inbound -Action Allow -Protocol TCP -LocalPort 3000
+New-NetFirewallRule -DisplayName "WSL Planet 8000" -Direction Inbound -Action Allow -Protocol TCP -LocalPort 8000
+```
+
+检查转发规则是否生效：
+
+```powershell
+netsh interface portproxy show all
+```
+
+预期能看到：
+
+- `0.0.0.0:3000 -> 127.0.0.1:3000`
+- `0.0.0.0:8000 -> 127.0.0.1:8000`
+
+### 5. 查 Windows 局域网 IP，并让其他设备访问
+
+在 Windows PowerShell 中执行：
+
+```powershell
+ipconfig
+```
+
+找到当前联网网卡的 IPv4 地址，例如 `192.168.8.228`。
+
+局域网其他设备可访问：
+
+- `http://<Windows局域网IP>:3000/earth`
+- `http://<Windows局域网IP>:3000/admin`
+
+例如：
+
+- `http://192.168.8.228:3000/earth`
+
+### 6. 常见现象与判断
+
+- WSL 中 `curl localhost:3000` 能通，但 Windows 访问 `WSL 的局域网 IP:3000` 不通：这是正常现象之一，优先验证 Windows 的 `localhost:3000`
+- Windows `localhost:3000` 能通，但局域网设备访问 `Windows 局域网 IP:3000` 不通：通常缺少 `portproxy` 或防火墙放行
+- `whoami /groups` 中 `S-1-5-32-544` 显示 `deny only`：说明当前 PowerShell 不是提权管理员窗口
+
+### 7. 本项目一次性验证顺序
+
+建议固定按这个顺序验证：
+
+1. WSL 中执行 `curl http://localhost:3000`
+2. WSL 中执行 `curl http://localhost:8000/health`
+3. Windows 中执行 `curl http://localhost:3000`
+4. Windows 中执行 `curl http://localhost:8000/health`
+5. 管理员 PowerShell 配置 `portproxy` 和防火墙
+6. 用手机或其他电脑访问 `http://<Windows局域网IP>:3000/earth`
+
 ## 启动容错参数

 `planet.sh` 现在为依赖安装、数据库、AI Provider 启动加入了有限次重试，并会在数据库与 `aiprovider` 启动后额外等待 Docker healthcheck。
--- a/TODO.md
+++ b/TODO.md
@@ -24,3 +24,11 @@
 - [ ] 如果后续明确需要“账号级同步 Earth 偏好”，再单独设计 `Earth user preferences`：优先按用户维度而不是全局系统设置保存，并规划 `localStorage -> backend` 的平滑迁移策略
 - [ ] 把 Earth 态势新闻源从 [earth_news.py](/home/ray/dev/linkong/planet/backend/app/services/earth_news.py) 的硬编码列表抽成可配置目录，优先保持当前“实时聚合”链路不变，只先解决新闻源不可配置的问题
 - [ ] 为 Earth 态势新闻设计后续采集器化方案：明确新闻数据模型、去重策略、区域映射、过期清理和 Earth/AI 复用方式，再决定何时把新闻从实时抓取升级成正式 collector
+- [ ] 为未知位置的算力中心建立分层坐标补全链路：优先 `精确坐标 > 站点/园区命中 > 城市 > 州/省 > 国家内主要算力城市 > 国家质心`，并把每次回退的 `confidence / reason / precision` 明确写进统一 GeoJSON
+- [ ] 为算力中心补一份可维护的本地位置注册表，例如 `canonical_name / aliases / operator / country / region / city / lat / lon / confidence / source_note`，避免把地点知识长期硬编码在 `visualization.py`
+- [ ] 增强 `epoch_ai_gpu` 和相关算力采集器的源页面解析：即使公开 API 不给坐标，也继续尝试从详情页、HTML、内嵌 JSON、schema.org、OpenGraph、脚本变量和 PDF/新闻稿链接里抽地点线索
+- [ ] 为未知位置算力中心增加外部富化策略评估：可选接入公开知识源或搜索兜底，只抓“站点名/园区名/城市名”级别线索，不直接抓经纬度结论，并把结果作为候选证据而不是真值
+- [ ] 为算力中心建立 `operator / cluster name / facility alias` 归一化层，先解决 `xAI / Colossus / Memphis`、`OpenAI / Stargate`、`CoreWeave`、`Lambda`、`Crusoe` 这类同一对象多种写法导致的地点匹配失败
+- [ ] 为估算位置增加更细的视觉和产品表达：除了问号角标，还要支持 tooltip/详情中的“估算依据”“精度级别”“最后核验时间”，并允许在设置中单独开关“仅看精确位置”
+- [ ] 为国家级估算点设计更合理的落点策略：优先落在“该国主要算力/数据中心城市候选集”而不是几何质心，必要时同国多节点做稳定散列分配，避免大量节点堆在荒漠或海上
+- [ ] 为未知位置算力中心建立人工校验工作流：支持导出待核验清单、记录人工确认结果，并把人工确认反哺到位置注册表，逐步减少问号点比例
--- a/2
+++ b/2
@@ -1 +1 @@
-0.34.0
+0.37.0
--- a/backend/app/api/v1/visualization.py
+++ b/backend/app/api/v1/visualization.py
@@ -13,6 +13,7 @@ from sqlalchemy import select, func
 from typing import List, Dict, Any, Optional

 from app.core.collected_data_fields import get_record_field
+from app.core.countries import get_country_centroid
 from app.core.satellite_tle import build_tle_lines_from_elements
 from app.core.time import to_iso8601_utc
 from app.db.session import get_db
@@ -363,6 +364,215 @@ def convert_gpu_cluster_to_geojson(records: List[CollectedData]) -> Dict[str, An
    return {"type": "FeatureCollection", "features": features}


+def _parse_float(value: Any) -> Optional[float]:
+    try:
+        if value in (None, ""):
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+COMPUTE_CENTER_COORDINATE_HINTS = (
+    ("el capitan", 37.6819, -121.7681),
+    ("livermore", 37.6819, -121.7681),
+    ("llnl", 37.6819, -121.7681),
+    ("lawrence livermore", 37.6819, -121.7681),
+    ("frontier", 35.9319, -84.3107),
+    ("oak ridge", 35.9319, -84.3107),
+    ("ornl", 35.9319, -84.3107),
+    ("aurora", 41.7130, -87.9820),
+    ("argonne", 41.7130, -87.9820),
+    ("anl", 41.7130, -87.9820),
+    ("fugaku", 34.6953, 135.1974),
+    ("kobe", 34.6953, 135.1974),
+    ("riken", 34.6953, 135.1974),
+    ("summit", 35.9319, -84.3107),
+    ("leonardo", 44.4949, 11.3426),
+    ("bologna", 44.4949, 11.3426),
+    ("alps", 46.0037, 8.9511),
+    ("lugano", 46.0037, 8.9511),
+    ("sunway taihulight", 31.4912, 120.3119),
+    ("wuxi", 31.4912, 120.3119),
+    ("tianhe-2", 23.1291, 113.2644),
+    ("tianhe-2a", 23.1291, 113.2644),
+    ("guangzhou", 23.1291, 113.2644),
+    ("colossus", 35.1495, -90.0490),
+    ("memphis", 35.1495, -90.0490),
+    ("xai", 35.1495, -90.0490),
+)
+
+
+def _normalize_hint_text(*parts: Any) -> str:
+    return " ".join(
+        str(part).strip().lower()
+        for part in parts
+        if part not in (None, "")
+    )
+
+
+def _resolve_compute_center_coordinates(
+    record: CollectedData,
+    metadata: Dict[str, Any],
+) -> Dict[str, Any]:
+    latitude = _parse_float(get_record_field(record, "latitude"))
+    longitude = _parse_float(get_record_field(record, "longitude"))
+    if latitude not in (None, 0.0) and longitude not in (None, 0.0):
+        return {
+            "latitude": latitude,
+            "longitude": longitude,
+            "location_precision": "precise",
+            "geography_mode": "source_coordinates",
+            "is_estimated": False,
+            "estimated_reason": None,
+        }
+
+    hint_text = _normalize_hint_text(
+        record.name,
+        get_record_field(record, "city"),
+        get_record_field(record, "country"),
+        metadata.get("site"),
+        metadata.get("organization"),
+        metadata.get("operator"),
+    )
+    for needle, resolved_latitude, resolved_longitude in COMPUTE_CENTER_COORDINATE_HINTS:
+        if needle in hint_text:
+            return {
+                "latitude": resolved_latitude,
+                "longitude": resolved_longitude,
+                "location_precision": "estimated_site",
+                "geography_mode": "site_hint",
+                "is_estimated": True,
+                "estimated_reason": f"Matched known site hint: {needle}",
+            }
+
+    centroid = get_country_centroid(get_record_field(record, "country"))
+    if centroid:
+        return {
+            "latitude": centroid.get("latitude"),
+            "longitude": centroid.get("longitude"),
+            "location_precision": "estimated_country",
+            "geography_mode": "country_centroid",
+            "is_estimated": True,
+            "estimated_reason": "Estimated from country centroid",
+        }
+
+    return {
+        "latitude": latitude,
+        "longitude": longitude,
+        "location_precision": "unknown",
+        "geography_mode": "unknown",
+        "is_estimated": True,
+        "estimated_reason": "No resolvable location hints",
+    }
+
+
+def _normalize_capacity_band(capacity_value: Optional[float], capacity_unit: str) -> str:
+    if capacity_value is None:
+        return "unknown"
+
+    unit = str(capacity_unit or "").strip().lower()
+    if unit in {"pflop/s", "pflops", "pflop"}:
+        normalized_tflops = capacity_value * 1000
+    elif unit in {"gflop/s", "gflops", "gflop"}:
+        normalized_tflops = capacity_value / 1000
+    else:
+        normalized_tflops = capacity_value
+
+    if normalized_tflops >= 1_000_000:
+        return "exascale"
+    if normalized_tflops >= 100_000:
+        return "ultra"
+    if normalized_tflops >= 10_000:
+        return "large"
+    if normalized_tflops > 0:
+        return "regional"
+    return "unknown"
+
+
+def convert_compute_centers_to_geojson(records: List[CollectedData]) -> Dict[str, Any]:
+    """Convert compute infrastructure records into a unified GeoJSON layer."""
+    features = []
+
+    for record in records:
+        metadata = record.extra_data or {}
+        coordinate_info = _resolve_compute_center_coordinates(record, metadata)
+        latitude = coordinate_info.get("latitude")
+        longitude = coordinate_info.get("longitude")
+        site_type = (
+            "supercomputer"
+            if record.source == "top500" or record.data_type == "supercomputer"
+            else "gpu_cluster"
+        )
+        if latitude in (None, 0.0) or longitude in (None, 0.0):
+            continue
+
+        if site_type == "supercomputer":
+            capacity_value = _parse_float(get_record_field(record, "rmax"))
+            capacity_unit = "GFlops"
+        else:
+            capacity_value = _parse_float(get_record_field(record, "value"))
+            capacity_unit = str(get_record_field(record, "unit") or "TFlop/s")
+
+        vendor = (
+            metadata.get("manufacturer")
+            or metadata.get("vendor")
+            or metadata.get("gpu_type")
+        )
+        operator = (
+            metadata.get("organization")
+            or metadata.get("operator")
+            or metadata.get("owner")
+        )
+        rank = metadata.get("rank")
+        if rank in (None, "") and site_type == "supercomputer":
+            rank = get_record_field(record, "rank")
+
+        updated_at = to_iso8601_utc(record.reference_date or record.collected_at)
+
+        features.append(
+            {
+                "type": "Feature",
+                "id": record.id,
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [longitude or 0, latitude or 0],
+                },
+                "properties": {
+                    "id": record.id,
+                    "source_id": record.source_id,
+                    "name": record.name,
+                    "site_type": site_type,
+                    "country": get_record_field(record, "country"),
+                    "city": get_record_field(record, "city"),
+                    "latitude": latitude,
+                    "longitude": longitude,
+                    "operator": operator,
+                    "vendor": vendor,
+                    "capacity_value": capacity_value,
+                    "capacity_unit": capacity_unit,
+                    "capacity_band": _normalize_capacity_band(capacity_value, capacity_unit),
+                    "rank": rank,
+                    "gpu_count": metadata.get("gpu_count"),
+                    "gpu_type": metadata.get("gpu_type"),
+                    "cores": get_record_field(record, "cores"),
+                    "power": get_record_field(record, "power"),
+                    "source": record.source,
+                    "updated_at": updated_at,
+                    "status": "observed",
+                    "location_precision": coordinate_info.get("location_precision"),
+                    "geography_mode": coordinate_info.get("geography_mode"),
+                    "is_estimated": coordinate_info.get("is_estimated", False),
+                    "estimated_reason": coordinate_info.get("estimated_reason"),
+                    "data_type": "compute_center",
+                    "metadata": metadata,
+                },
+            }
+        )
+
+    return {"type": "FeatureCollection", "features": features}
+
+
 def convert_bgp_anomalies_to_geojson(
    records: List[BGPAnomaly],
    geography_hints: Optional[Dict[str, Dict[str, Any]]] = None,
@@ -975,6 +1185,53 @@ async def get_gpu_clusters_geojson(
    }


+@router.get("/geo/compute-centers")
+async def get_compute_centers_geojson(
+    limit: int = Query(200, ge=1, le=1000),
+    db: AsyncSession = Depends(get_db),
+):
+    """获取统一算力中心 GeoJSON 数据"""
+    records_by_source = await _load_current_collected_data_by_sources(
+        db,
+        ["top500", "epoch_ai_gpu"],
+    )
+    records = _filter_known_records(
+        records_by_source.get("top500", []) + records_by_source.get("epoch_ai_gpu", []),
+    )
+    if limit is not None:
+        records = records[:limit]
+
+    if not records:
+        return {
+            "type": "FeatureCollection",
+            "features": [],
+            "count": 0,
+            "stats": {
+                "total": 0,
+                "supercomputers": 0,
+                "gpu_clusters": 0,
+            },
+        }
+
+    geojson = convert_compute_centers_to_geojson(records)
+    features = geojson.get("features", [])
+    return {
+        **geojson,
+        "count": len(features),
+        "stats": {
+            "total": len(features),
+            "supercomputers": sum(
+                1 for feature in features
+                if feature.get("properties", {}).get("site_type") == "supercomputer"
+            ),
+            "gpu_clusters": sum(
+                1 for feature in features
+                if feature.get("properties", {}).get("site_type") == "gpu_cluster"
+            ),
+        },
+    }
+
+
@router.get("/geo/bgp-anomalies")
 async def get_bgp_anomalies_geojson(
    severity: Optional[str] = Query(None),
--- a/backend/tests/test_visualization_compute_centers.py
+++ b/backend/tests/test_visualization_compute_centers.py
@@ -0,0 +1,217 @@
+from datetime import datetime, timezone
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.api.v1.visualization import convert_compute_centers_to_geojson
+from app.db.session import get_db
+from app.main import app
+from app.models.collected_data import CollectedData
+
+
+def _build_record(
+    *,
+    record_id: int,
+    source: str,
+    data_type: str,
+    name: str,
+    country: str,
+    city: str,
+    latitude: float,
+    longitude: float,
+    metadata: dict,
+):
+    return CollectedData(
+        id=record_id,
+        source=source,
+        data_type=data_type,
+        source_id=f"{source}-{record_id}",
+        name=name,
+        extra_data={
+            "country": country,
+            "city": city,
+            "latitude": latitude,
+            "longitude": longitude,
+            **metadata,
+        },
+        collected_at=datetime(2026, 4, 22, tzinfo=timezone.utc),
+        reference_date=datetime(2026, 4, 21, tzinfo=timezone.utc),
+        is_current=True,
+    )
+
+
+def test_convert_compute_centers_to_geojson_unifies_sources():
+    top500_record = _build_record(
+        record_id=1,
+        source="top500",
+        data_type="supercomputer",
+        name="Frontier",
+        country="United States",
+        city="Oak Ridge",
+        latitude=35.93,
+        longitude=-84.31,
+        metadata={
+            "rank": 1,
+            "manufacturer": "HPE",
+            "organization": "ORNL",
+            "rmax": 1102000.0,
+            "cores": 8730112,
+            "power": 21510.0,
+        },
+    )
+    gpu_record = _build_record(
+        record_id=2,
+        source="epoch_ai_gpu",
+        data_type="gpu_cluster",
+        name="Colossus",
+        country="United States",
+        city="Memphis",
+        latitude=35.15,
+        longitude=-90.05,
+        metadata={
+            "organization": "xAI",
+            "gpu_type": "H100",
+            "gpu_count": 100000,
+            "value": "20000",
+            "unit": "TFlop/s",
+        },
+    )
+
+    payload = convert_compute_centers_to_geojson([top500_record, gpu_record])
+
+    assert payload["type"] == "FeatureCollection"
+    assert len(payload["features"]) == 2
+
+    supercomputer_feature = payload["features"][0]
+    assert supercomputer_feature["properties"]["site_type"] == "supercomputer"
+    assert supercomputer_feature["properties"]["capacity_unit"] == "GFlops"
+    assert supercomputer_feature["properties"]["capacity_band"] == "exascale"
+    assert supercomputer_feature["properties"]["operator"] == "ORNL"
+    assert supercomputer_feature["properties"]["location_precision"] == "precise"
+    assert supercomputer_feature["properties"]["is_estimated"] is False
+
+    gpu_feature = payload["features"][1]
+    assert gpu_feature["properties"]["site_type"] == "gpu_cluster"
+    assert gpu_feature["properties"]["vendor"] == "H100"
+    assert gpu_feature["properties"]["gpu_count"] == 100000
+    assert gpu_feature["properties"]["capacity_band"] == "large"
+    assert gpu_feature["properties"]["location_precision"] == "precise"
+
+
+def test_convert_compute_centers_to_geojson_uses_coordinate_hints():
+    hinted_record = _build_record(
+        record_id=3,
+        source="top500",
+        data_type="supercomputer",
+        name="Frontier",
+        country="United States",
+        city="",
+        latitude=0.0,
+        longitude=0.0,
+        metadata={
+            "organization": "Oak Ridge National Laboratory",
+            "rmax": 1102000.0,
+        },
+    )
+
+    payload = convert_compute_centers_to_geojson([hinted_record])
+
+    assert len(payload["features"]) == 1
+    coords = payload["features"][0]["geometry"]["coordinates"]
+    assert coords[0] == pytest.approx(-84.3107)
+    assert coords[1] == pytest.approx(35.9319)
+    assert payload["features"][0]["properties"]["is_estimated"] is True
+    assert payload["features"][0]["properties"]["location_precision"] == "estimated_site"
+
+
+def test_convert_compute_centers_to_geojson_falls_back_to_country_centroid():
+    centroid_record = _build_record(
+        record_id=4,
+        source="epoch_ai_gpu",
+        data_type="gpu_cluster",
+        name="Unknown Cluster",
+        country="United States",
+        city="",
+        latitude=0.0,
+        longitude=0.0,
+        metadata={
+            "organization": "Unknown Operator",
+            "value": "10000",
+            "unit": "TFlop/s",
+        },
+    )
+
+    payload = convert_compute_centers_to_geojson([centroid_record])
+
+    assert len(payload["features"]) == 1
+    props = payload["features"][0]["properties"]
+    coords = payload["features"][0]["geometry"]["coordinates"]
+    assert coords[0] == pytest.approx(-98.5795)
+    assert coords[1] == pytest.approx(39.8283)
+    assert props["is_estimated"] is True
+    assert props["location_precision"] == "estimated_country"
+    assert props["geography_mode"] == "country_centroid"
+
+
+@pytest.mark.asyncio
+async def test_compute_centers_geojson_endpoint_returns_stats():
+    records = [
+        _build_record(
+            record_id=1,
+            source="top500",
+            data_type="supercomputer",
+            name="Frontier",
+            country="United States",
+            city="Oak Ridge",
+            latitude=35.93,
+            longitude=-84.31,
+            metadata={"rank": 1, "rmax": 1102000.0},
+        ),
+        _build_record(
+            record_id=2,
+            source="epoch_ai_gpu",
+            data_type="gpu_cluster",
+            name="Colossus",
+            country="United States",
+            city="Memphis",
+            latitude=35.15,
+            longitude=-90.05,
+            metadata={"value": "20000", "unit": "TFlop/s"},
+        ),
+    ]
+
+    class _ScalarResult:
+        def __init__(self, rows):
+            self._rows = rows
+
+        def scalars(self):
+            class _Scalars:
+                def __init__(self, rows):
+                    self._rows = rows
+
+                def all(self):
+                    return self._rows
+
+            return _Scalars(self._rows)
+
+    class _FakeSession:
+        async def execute(self, _query):
+            return _ScalarResult(records)
+
+    async def override_get_db():
+        yield _FakeSession()
+
+    app.dependency_overrides[get_db] = override_get_db
+    transport = ASGITransport(app=app)
+    try:
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            response = await client.get("/api/v1/visualization/geo/compute-centers")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["count"] == 2
+        assert data["stats"]["supercomputers"] == 1
+        assert data["stats"]["gpu_clusters"] == 1
+        assert data["features"][0]["properties"]["data_type"] == "compute_center"
+    finally:
+        app.dependency_overrides.clear()
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -8,6 +8,74 @@ This project follows the repository versioning rule:
 - `improvement` -> `+0.0.1`（bugfix + 小功能混合）
 - `bugfix` -> `+0.0.1`

+## [0.35.1] — 2026-04-22
+## [0.37.0] — 2026-04-23
+
+### ✨ Highlights
+- Earth 连线系统正式从巡航里解耦成通用 callout connector：桌面端和移动端统一支持对象级锚点、四边切换与临界区边缘滑动
+- BGP 巡航展示继续收口为稳定的“先定位卡片、再连真实锚点、再展示卡片”链路，移动端 popup 与桌面 info panel 的路线规则统一
+
+### 🔧 Improvements
+- connector 配置从 `CRUISE_CONFIG` 拆到独立 `CONNECTOR_CONFIG`，默认类名、动画名和实例命名也全部去 cruise 语义
+- 移动端 popup 增加更稳定的 dock/obstacle 处理，拖动卡片时连线起终点会持续按几何关系自适应刷新
+- Earth 多个图层与控制逻辑继续收口，补充算力中心/BGP 风格对齐、layer panel 与相关交互细节调整
+
+### 🐛 Fixes
+- 修复巡航模式下终点只像“视觉锚点”而不是真实绑定对象的问题，卡片拖动后终点现在会跟随
+- 修复移动端与桌面端多类连线路线异常：压线、反向、临界区折返、起点遮挡事件点等问题
+- 修复对象矩形临界区内连线仍强制中点到中点导致路线像“先钻进 source 内部”再出去的问题
+
+---
+
+## [0.35.1] — 2026-04-22
+## [0.36.0] — 2026-04-22
+
+### ✨ Highlights
+- Earth 新增统一“算力中心”图层：接入超算与 GPU 集群，支持搜索、统计、图例、详情卡与独立图层开关
+- 算力中心支持精确位置与估算位置两种状态，估算点会以问号角标区分，避免数据不全时整批节点在地图上消失
+
+### 🔧 Improvements
+- Earth 详情卡拖拽与地球拖拽交互继续收口，减少拖动卡片和旋转地球时的选中文本与 pointer 竞争
+- `planet.sh` 改为通过独立脚本计算 AI Provider 依赖指纹，降低与根仓库依赖版本文件的无关耦合
+- README 补充 WSL / Windows 局域网访问排查与转发配置说明，便于开发环境联调
+
+### 🐛 Fixes
+- 修复 Earth 算力中心图层在无原始坐标时无法显示的问题，支持站点提示和国家级估算回退
+- 修复信息卡拖拽事件可能被卡片级 stopPropagation 吞掉，导致拖拽流中断的问题
+
+---
+
+## [0.35.1] — 2026-04-22
+
+### ✨ Highlights
+- Earth 统计展示改为统一 `data-earth-stat` 绑定机制，桌面 HUD 和移动端抽屉复用同一套状态更新入口
+
+### 🔧 Improvements
+- 收口海缆、登陆点、卫星、BGP 事件与 BGP 状态的统计写入逻辑，减少后续继续补桌面/移动双写分支的成本
+
+### 🐛 Fixes
+- 修复移动端态势抽屉中的海缆、登陆点与 BGP 统计在图层切换后可能停留旧值的问题
+
+---
+
+## [0.35.0] — 2026-04-22
+
+### ✨ Highlights
+- Earth 移动端底部抽屉系统全面上线：响应式布局自动切换、Tab 导航、手势上拉/下滑开合、惯性速度判定
+- 移动端点击可交互物件（海缆、登陆点、卫星、BGP）后弹出智能定位悬浮卡片，可拖动，点击跳转详情
+
+### 🔧 Improvements
+- 抽屉把手区域缩小至 36px（collapsed 时仅露出把手，不遮挡地球操作区）
+- 抽屉定期弹跳动画提示用户可上拉，5 秒间隔，打开后自动停止
+- 通知胶囊位置调整，不再覆盖品牌 logo
+- 移动端单指旋转、双指捏合缩放地球，触控事件冲突修复（pointer-events 级联）
+
+### 🐛 Fixes
+- 修复移动端抽屉 shell 因 layout 高度（240px+）遮挡地球触控区域，pointer-events 改为按层级精确控制
+- 修复悬浮卡片因 setPointerCapture 在 iOS Safari 抑制合成 click 事件导致无法点击的问题
+
+---
+
 ## [0.34.0] — 2026-04-22

 ### ✨ Highlights
--- a/docs/plans/README.md
+++ b/docs/plans/README.md
@@ -16,6 +16,8 @@

 当前重点入口：

+- [earth-mobile-drawer-ui-plan.md](/home/ray/dev/linkong/planet/docs/plans/earth-mobile-drawer-ui-plan.md)
+- [earth-compute-center-bgp-style-plan.md](/home/ray/dev/linkong/planet/docs/plans/earth-compute-center-bgp-style-plan.md)
 - [earth-renderer-architecture-separation-plan.md](/home/ray/dev/linkong/planet/docs/plans/earth-renderer-architecture-separation-plan.md)
 - [earth-predicted-orbit-plan.md](/home/ray/dev/linkong/planet/docs/plans/earth-predicted-orbit-plan.md)
 - [earth-webgl-instancing-satellites-plan.md](/home/ray/dev/linkong/planet/docs/plans/earth-webgl-instancing-satellites-plan.md)
--- a/docs/plans/earth-compute-center-bgp-style-plan.md
+++ b/docs/plans/earth-compute-center-bgp-style-plan.md
@@ -0,0 +1,372 @@
+# Earth Compute Center BGP-Style Plan
+
+## Goal
+
+这份文档定义如何按照 BGP 模块的产品方式，把“算力中心”提升为 Earth 上的一级能力。
+
+这里的“按 BGP 方式”指的是：
+
+- 有独立的数据语义和接口入口
+- 有独立的 Earth 图层与图例
+- 有独立的 hover / click / 选中态 / 详情卡
+- 有独立的统计口径与后续专题页扩展空间
+
+这里的“按 BGP 方式”不指：
+
+- 机械复制 BGP 的 anomaly / incident / collector 三层事件模型
+- 为静态算力设施强行引入不必要的复杂告警语义
+
+算力中心本质上更接近“长期基础设施分布层”，不是“高频动态异常层”。
+因此应该复用 BGP 的模块化方法，而不是照搬 BGP 的事件结构。
+
+## Why
+
+当前仓库里已经有算力相关基础：
+
+- 后端已有 `top500` 和 `epoch_ai_gpu` 数据采集
+- 可视化接口已有 `/api/v1/visualization/geo/supercomputers` 和 `/api/v1/visualization/geo/gpu-clusters`
+- Earth 信息卡已对 `supercomputer` 和 `gpu_cluster` 做了基础类型兼容
+
+但当前能力还停留在“数据可取到”的阶段，没有形成像 BGP 那样完整的可视化模块：
+
+- Earth 缺少独立的算力图层加载模块
+- 缺少算力 marker 体系和视觉层级
+- 缺少算力图例、统计、开关和搜索接入
+- 缺少与海缆、BGP、卫星的关系表达
+- 缺少算力专题页和后续告警/研判扩展入口
+
+所以当前真正的缺口不是“有没有数据”，而是“有没有产品级模块”。
+
+## Core Principle
+
+算力中心应当采用和 BGP 一致的模块化分层：
+
+1. 数据层：稳定的数据契约和 GeoJSON 输出
+2. 渲染层：独立的 Earth 图层、marker 和视觉状态管理
+3. 交互层：hover、click、锁定态、详情卡、图例和统计
+4. 扩展层：后续专题页、关系分析、告警和 AI 研判
+
+但语义上必须保持算力中心自身的特点：
+
+- `site / center` 是主对象，不是事件
+- `capacity / rank / vendor / operator / status` 是主信息，不是异常严重度
+- `distribution / concentration / dependency` 是后续分析方向，不是第一阶段必须项
+
+## Recommended Scope
+
+第一版“算力中心”建议统一承载两类对象：
+
+- `supercomputer`
+- `gpu_cluster`
+
+并在 Earth 上收口为一个主题层：`compute_centers`
+
+这样做有几个好处：
+
+- 用户看到的是统一的“算力基础设施”语义，而不是零散数据源
+- 后端仍可保留 `top500` 和 `epoch_ai_gpu` 的来源差异
+- 前端可以在一个图层里再细分两种 marker 语言
+
+## Current Gap
+
+和 BGP 对比，当前差距主要在下面几层。
+
+### 1. Data Contract Gap
+
+现在的算力 GeoJSON 还是通用 `collected_data` 输出思路，字段较轻：
+
+- `gpu_cluster` 只有基础名称和地点
+- `supercomputer` 只暴露一部分性能字段
+- 缺少统一的 `site_type / operator / capacity_band / source / updated_at / confidence`
+- 缺少统一的算力层聚合出口
+
+### 2. Earth Rendering Gap
+
+当前 Earth 里没有类似 `bgp.js` 的算力模块：
+
+- `constants.js` 没有算力 API 路径和视觉配置
+- `main.js` 没有算力加载、拾取、状态同步和 HUD 更新
+- `controls.js` 没有算力图层开关和启动加载优先级
+- `layer-startup-tasks.js` 没有算力启动任务
+- `legend.js` / `ui.js` 没有算力统计与图例模式
+
+### 3. Interaction Gap
+
+虽然 `info-card.js` 支持基础字段，但还没有形成 BGP 那种完整交互链路：
+
+- 没有 hover / selected / dimmed 的视觉状态
+- 没有算力对象专属 tooltip 与摘要文案
+- 没有锁定后与其他基础设施的联动高亮
+- 没有搜索、统计卡和详情组织方式
+
+### 4. Product Expansion Gap
+
+当前还没有“算力中心”专题页与分析语义：
+
+- 没有全球分布/国家聚合/厂商聚合视图
+- 没有算力与海缆/BGP/区域的关系表达
+- 没有 AI brief / assessment 的后续落点
+
+## Architecture Direction
+
+推荐把算力中心做成“BGP 同级能力”，但采用更适合静态基础设施的结构。
+
+### Backend
+
+建议新增统一聚合接口，例如：
+
+- `/api/v1/visualization/geo/compute-centers`
+
+它的职责是把：
+
+- `top500`
+- `epoch_ai_gpu`
+
+统一转换成一个主题层输出，同时保留对象细分类型：
+
+- `site_type: supercomputer | gpu_cluster`
+
+建议统一字段至少包括：
+
+- `id`
+- `name`
+- `site_type`
+- `country`
+- `city`
+- `latitude`
+- `longitude`
+- `operator`
+- `vendor`
+- `capacity_value`
+- `capacity_unit`
+- `capacity_band`
+- `rank`
+- `source`
+- `updated_at`
+- `location_precision`
+- `geography_mode`
+- `is_estimated`
+- `estimated_reason`
+- `metadata`
+
+这里建议优先做“统一聚合出口”，而不是一开始就新增独立数据库表。
+
+原因：
+
+- 当前源数据更新频率低，先复用 `collected_data` 成本更低
+- 可以先把 Earth 产品体验做完整
+- 如果后续要做历史趋势、关系推断、告警，再评估是否拆成独立模型
+
+### Frontend Earth
+
+建议新增独立模块，例如：
+
+- `frontend/public/earth/js/compute-centers.js`
+
+职责参照 `bgp.js`：
+
+- 拉取算力中心 GeoJSON
+- 创建 marker
+- 管理 hover / selected / dimmed 状态
+- 输出图例项
+- 输出统计摘要
+- 提供 overlay 和详情格式化辅助函数
+
+推荐视觉分层：
+
+1. `supercomputer` 用更稳定、更规整的设施型符号
+2. `gpu_cluster` 用更活跃、更现代的密度型符号
+3. 选中态通过 halo / ring / related infrastructure highlight 表达
+
+视觉上应避免把算力中心做成“BGP 事件点”那种高频脉冲风格。
+它应该更像长期存在的高价值设施。
+
+## Phases
+
+## Phase 1: Unified Earth Layer
+
+目标：
+
+- 先把算力中心做成 Earth 上可用、可点、可解释的一级图层
+
+工作项：
+
+- 新增统一算力 GeoJSON 接口
+- 新增 `compute-centers.js`
+- 在 `constants.js` 增加 API 路径和视觉配置
+- 在 `controls.js` 增加算力图层开关与启动元数据
+- 在 `layer-startup-tasks.js` 增加算力启动加载任务
+- 在 `main.js` 接入算力拾取、hover、click、锁定态和 HUD 统计
+- 在 `ui.js` / `legend.js` / `index.html` 增加算力统计与图例入口
+- 在 `info-card.js` 提升算力详情字段组织
+- 对无法精确定位、但可按国家或弱线索推测的大概位置，仍然生成地图点位
+- 这类对象必须带显式“估算位置”状态，例如图标问号角标与详情说明
+
+完成标准：
+
+- Earth 上能独立显示/隐藏算力中心
+- 两类对象有可区分的视觉表达
+- hover / click / 详情卡 / 图例 / 统计全部打通
+- 精确位置与估算位置在图标或文案上可区分，不会误导为同一精度
+- 不干扰现有海缆、卫星、BGP 的交互链路
+
+## Phase 2: Relationship Layer
+
+目标：
+
+- 让算力中心不只是“点”，而是和其他基础设施产生上下文关系
+
+工作项：
+
+- 建立算力中心与国家/区域聚合摘要
+- 增加与附近海缆登陆点的关系提示
+- 增加与 BGP 事件/观测范围的空间邻近提示
+- 增加与卫星覆盖或区域连通性的实验性提示
+
+完成标准：
+
+- 点击算力中心时，用户能看到“它和哪些基础设施相关”
+- 信息表达以辅助判断为主，不做夸张推断
+
+## Phase 3: Compute Center Observatory
+
+目标：
+
+- 把算力中心从 Earth 图层扩展成独立专题观测能力
+
+工作项：
+
+- 新增算力中心专题页
+- 提供国家/厂商/类型/容量分布统计
+- 支持列表、筛选、详情和历史快照
+- 预留 AI brief / assessment 入口
+
+完成标准：
+
+- 算力中心不再只是 Earth 上的视觉点位
+- 能作为独立业务上下文进入日常观察与研判
+
+## Phase 4: Alerts And Assessment
+
+目标：
+
+- 在不滥造“假动态告警”的前提下，引入真正有价值的变化感知
+
+候选方向：
+
+- 新增大规模算力中心
+- 既有中心容量显著变化
+- 国家/区域集中度显著变化
+- 高价值中心与关键网络基础设施关系变化
+
+完成标准：
+
+- 告警来自可解释的结构变化
+- 不把静态数据硬做成噪声式实时事件流
+
+## Implementation Notes
+
+建议按下面顺序推进：
+
+1. 先统一 GeoJSON 契约
+2. 再做 Earth 独立模块和图层开关
+3. 再补详情卡、图例和统计
+4. 最后才做关系层和专题页
+
+这样可以避免一开始把范围摊得过大。
+
+## Unknown Location Strategy
+
+由于部分算力数据源不会直接提供经纬度，未知位置补全不能只依赖“继续找 API 字段”。
+更稳妥的方式是做成一条分层富化链路，而不是单一猜测规则。
+
+推荐按下面优先级推进：
+
+1. 直接源信息
+
+- 源记录显式给出 `latitude / longitude`
+- 源记录给出 `city / region / facility / campus / operator`
+- 源页面详情、内嵌 JSON、结构化元数据、新闻稿链接里能抽出地点线索
+
+2. 名称与机构归一化
+
+- 建立 `canonical_name / aliases / operator / facility` 归一化表
+- 把 `cluster name`、`operator`、`campus name` 归一到同一个实体
+- 优先解决同一对象多写法导致的命中失败，而不是先扩大猜测范围
+
+3. 本地位置注册表
+
+- 用仓库内可维护的 registry 保存高价值对象的位置知识
+- 每条记录至少包含：`canonical_name`、`aliases`、`operator`、`country`、`region`、`city`、`lat`、`lon`、`confidence`、`source_note`
+- 转换层优先读取 registry，避免地点知识长期散落在转换代码里
+
+4. 分层回退定位
+
+- `precise`
+- `estimated_site`
+- `estimated_city`
+- `estimated_region`
+- `estimated_national_hub`
+- `estimated_country`
+
+这里建议把“国家内主要算力城市”作为国家质心之前的一层。
+例如没有美国精确位置时，优先考虑已知的主要算力/数据中心城市候选，而不是直接落在几何质心。
+
+5. 候选证据富化
+
+- 如果源 API 无地点信息，可以允许采集链路读取公开辅助证据
+- 例如机构官网、数据中心介绍页、新闻稿、百科型页面、公开 PDF
+- 但只提取“地点线索”，不把外部页面上的经纬度当真值直接写回
+
+6. 人工校验闭环
+
+- 对高价值且仍然未知的对象输出待核验清单
+- 把人工确认结果回写到位置注册表
+- 后续采集继续优先复用这层人工确认结果
+
+### Additional Solution Paths
+
+除了静态映射表，还可以考虑下面这些办法：
+
+- 基于国家和运营方建立“主要园区候选集”，用稳定散列把同国未知节点分散到若干可信城市，而不是全部压到一个点
+- 基于数据中心/云厂商公开 region 列表建立 `operator -> city set` 候选映射，用于云 GPU 集群类对象
+- 把“估算依据”结构化，例如 `matched_alias`、`matched_operator`、`matched_city_text`、`fallback_country_hub`
+- 给位置补全增加 `last_verified_at`，便于后续按时间重新校验老旧映射
+- 单独维护“不可可靠定位”状态；这类对象仍可在国家级聚合统计中出现，但可以允许用户在地图上过滤掉
+- 后续如果你们愿意投入更多，可把这条链路做成小型 enrichment pipeline，而不是仅在 API 转换时临时判断
+
+## Non-Goals
+
+第一阶段不建议做这些内容：
+
+- 不复制 BGP 巡航模式到算力中心
+- 不先做复杂实时 websocket 推送
+- 不先引入独立 `compute_center_incident` 一类模型
+- 不先做全量 AI 分析面板
+
+原因是算力中心的第一需求是“被看清楚”，不是“被实时播报”。
+但“被看清楚”不等于“只显示精确坐标对象”。
+对于没有精确经纬度、但能推测到国家或区域级位置的算力中心，应优先以上图并标注估算状态的方式处理，而不是直接在地图上消失。
+
+## Acceptance Checklist
+
+- 后端存在统一的算力中心 GeoJSON 出口
+- Earth 有独立算力图层模块，而不是散落在 `main.js`
+- 页面上有清晰的算力开关、图例和统计
+- `supercomputer` 和 `gpu_cluster` 在视觉和详情上都可区分
+- 估算位置对象在地图和详情中都有明确状态提示
+- 现有 BGP / 海缆 / 卫星功能无回归
+- 代码结构上为后续专题页和关系分析留出了明确扩展点
+
+## Summary
+
+这项工作的本质不是“再多画几个点”。
+
+它应该把算力中心从已有数据源，升级成与 BGP 同级的 Earth 观测主题：
+
+- 有独立语义
+- 有独立图层
+- 有独立交互
+- 有后续分析扩展能力
+
+推荐先完成 Phase 1，把算力中心做成真正可用的 Earth 一级模块，再继续推进关系层和专题页。
--- a/docs/plans/earth-mobile-drawer-ui-plan.md
+++ b/docs/plans/earth-mobile-drawer-ui-plan.md
@@ -0,0 +1,400 @@
+# Earth Mobile Drawer UI Plan
+
+## 背景
+
+当前 Earth 移动端已经补上了基础触控能力，例如：
+
+- 单指拖拽旋转地球
+- 双指缩放
+- 点击阈值和基础事件隔离
+
+但移动端 UI 仍然存在一个根本问题：
+
+它还在沿用桌面 HUD 的内容切分方式，只是把原来的 panel、modal、toolbar 改位置、改层级、改容器。这样虽然能快速复用旧代码，但手机端体验仍然是生硬的，因为：
+
+- 信息密度和结构是按桌面设计的
+- 面板标题、关闭、折叠、开关项是桌面心智，不是手机心智
+- 很多内容只是“被塞进抽屉”，而不是为抽屉重新设计
+- 设置里仍然带有“显示/隐藏某些 panel”的思路，但移动端本来就不应该存在那些独立 panel
+
+因此本计划进一步收紧：
+
+移动端不只是“底部抽屉化”，而是**重新设计一套 fit 抽屉体系的 mobile-first UI**。
+
+## 新目标
+
+1. 手机端不再使用现有 `toolbar` 作为主入口。
+2. 手机端不再使用现有独立 `panel / modal / sheet` 作为直接 UI 单元。
+3. 手机端统一采用“底部抽屉 + 顶部标题 + tab 切换 + 卡片内容”的单前景模式。
+4. 抽屉内部每个 tab 页面都按移动端重新设计内容结构，而不是直接复用旧 panel 结构。
+5. 设置页移除“显示/隐藏 panel”的桌面遗留配置。
+6. 媒体页拆成两个移动端页面：`新闻` 与 `TV`，都归入抽屉体系。
+7. 桌面端保持现有 HUD 体系，不回退。
+
+## 核心原则
+
+### 1. 只复用数据和状态，不复用桌面 UI 结构
+
+可复用：
+
+- 图层注册表
+- 搜索结果数据
+- BGP / 海缆 / 卫星详情数据
+- 媒体数据
+- 旋转、缩放、选择、高亮等运行时状态
+
+不直接复用：
+
+- 桌面 panel DOM 结构
+- 桌面 panel header / close / collapse 交互
+- 桌面 settings 项里的“显示某 panel”逻辑
+- 桌面媒体面板布局
+
+### 2. 抽屉是唯一主前景层
+
+移动端同一时刻只有一个主前景层：底部抽屉。
+
+抽屉内部切换内容页，而不是多个悬浮层互相覆盖。
+
+### 3. 每个 tab 都是移动端页面，而不是 panel 容器
+
+抽屉中的每一项都应视为一个移动端子页面：
+
+- 有自己的标题
+- 有自己的内容层次
+- 有自己的滚动区域
+- 有自己的主操作
+
+而不是简单挂一个旧面板进去。
+
+### 4. 移动端状态提示不占据屏幕正中
+
+桌面端当前很多通知、状态提示、胶囊消息更适合在屏幕上方居中出现，但移动端不应继续沿用这套布局。
+
+移动端统一改为：
+
+- 通知栏放在右上角安全区
+- 胶囊提示放在右上角堆叠
+- 不遮挡地球中心视野
+- 不与底部抽屉主交互区冲突
+
+## 交互模型
+
+### 默认态
+
+移动端默认只显示：
+
+- 地球主画布
+- 底部半露出的抽屉头部
+
+不再单独显示上箭头按钮。
+
+### 展开态
+
+用户从底边直接上拉抽屉，或点击抽屉头部展开。
+
+展开后显示：
+
+- 当前页面标题
+- tab 导航
+- 当前页面内容
+
+### 收起态
+
+用户下拉抽屉头部收起，或点击背景收起。
+
+## 信息架构
+
+移动端抽屉内的一级页面重定为：
+
+1. 图层
+2. 搜索
+3. 态势
+4. 新闻
+5. TV
+6. 设置
+7. 详情（按需出现，不固定常驻 tab）
+
+其中 `新闻` 和 `TV` 不再共享同一个移动端媒体面板。
+
+## 页面重设计要求
+
+### 图层页
+
+目标：
+
+- 成为移动端最核心的控制页
+- 强调快速开关，不强调桌面 panel 感
+
+内容建议：
+
+- 顶部摘要：当前已启用图层数量
+- 图层列表卡片
+- 每个图层项只保留：
+  - 图标
+  - 中文名
+  - 英文副标题
+  - 开关
+- 去掉桌面式 header / collapse / close 结构
+
+### 搜索页
+
+目标：
+
+- 成为抽屉中的完整搜索页
+- 避免看起来像桌面 modal 被塞进抽屉
+
+内容建议：
+
+- 顶部搜索输入框
+- 搜索提示文案
+- 结果列表
+- 结果项更适合手指点击
+- 结果点击后：
+  - 聚焦地球对象
+  - 自动切换到详情页
+
+### 态势页
+
+目标：
+
+- 合并原来的 `stats + legend` 思路
+- 成为移动端全局态势页
+
+内容建议：
+
+- 顶部核心统计卡
+  - 海缆数量
+  - 登陆点数量
+  - 卫星数量
+  - BGP 事件数量
+- 当前关注层图例
+- BGP 状态摘要
+- 不再出现独立 legend 面板和独立 stats 面板
+
+### 新闻页
+
+目标：
+
+- 从原媒体面板中拆出单独的移动端新闻页
+
+内容建议：
+
+- 当前区域焦点
+- 新闻源数量
+- 新闻卡片列表
+- 卡片内显示标题、来源、时间、区域
+- 外链操作更清晰
+
+### TV 页
+
+目标：
+
+- 从原媒体面板中拆出单独的移动端 TV 页
+
+内容建议：
+
+- 顶部频道选择
+- 直播状态
+- 当前频道说明
+- 视频播放器区域
+- 刷新和外链按钮
+
+不再保留桌面式“新闻/TV tab 共处一个 panel”的结构。
+
+### 设置页
+
+目标：
+
+- 只保留对移动端仍有意义的系统配置
+
+必须移除：
+
+- 图层控制 panel 显示/隐藏
+- 图例 panel 显示/隐藏
+- 全球态势 panel 显示/隐藏
+- 媒体 panel 显示/隐藏
+
+保留项建议：
+
+- 旋转模式
+- 日夜模式
+- 地球默认大小
+- 地形透明度
+- 系统入口
+
+原因：
+
+移动端已经没有这些独立 panel 了，所以继续保留这些开关会制造错误心智。
+
+### 详情页
+
+目标：
+
+- 成为海缆 / BGP / 卫星对象的统一移动端详情页
+
+内容建议：
+
+- 标题区
+- 类型标签
+- 关键属性列表
+- 相关对象摘要
+- 相关图层或态势提示
+
+行为建议：
+
+- 点击对象后自动切入详情页
+- 搜索结果点击后也切入详情页
+
+## 阶段重定义
+
+### 阶段 2：抽屉壳层
+
+目标：
+
+1. 实现底部抽屉基本壳层。
+2. 支持上拉展开、下拉收起、背景点击关闭。
+3. `mobile` 模式下隐藏旧 toolbar。
+4. `mobile` 模式下不再直接显示旧 panel。
+
+完成标准：
+
+1. 手机端只有地球主视图和抽屉。
+2. 抽屉开合稳定。
+
+### 阶段 3：基础页面重做
+
+目标：
+
+1. 重新设计并实现图层页。
+2. 重新设计并实现搜索页。
+3. 重新设计并实现设置页。
+
+完成标准：
+
+1. 这三个页面不再是旧 panel 原样移植。
+2. 设置页已移除 panel 可见性开关。
+
+### 阶段 4：态势与详情重做
+
+目标：
+
+1. 将 stats 和 legend 合并为新的态势页。
+2. 实现统一详情页。
+3. 对象点击与搜索结果点击都可切入详情页。
+
+完成标准：
+
+1. 不再存在移动端独立 legend / stats 面板。
+2. 详情页成为统一对象信息入口。
+
+### 阶段 5：媒体拆分重做
+
+目标：
+
+1. 将原媒体面板拆成两个移动端页面：新闻页、TV 页。
+2. 分别重做这两个页面的布局。
+3. 保留各自必要操作，但不继续共享桌面 panel 结构。
+
+完成标准：
+
+1. 新闻与 TV 各自成为独立移动端页面。
+2. 不再使用桌面媒体 panel 的 tab 结构作为移动端主体。
+
+### 阶段 6：手感与真机修正
+
+目标：
+
+1. 调整抽屉高度、节奏、手势阈值。
+2. 调整 tab 密度与文字层级。
+3. 优化 iPhone / Android 安全区。
+4. 优化抽屉滚动与地球拖拽边界。
+
+完成标准：
+
+1. 抽屉和地球不会抢手势。
+2. 手机端各页面信息层次清晰。
+3. 真机下无遮挡、无死层、无错误交互心智。
+
+## 技术落点调整
+
+### [frontend/public/earth/index.html](/home/ray/dev/linkong/planet/frontend/public/earth/index.html)
+
+职责：
+
+- 只保留移动端抽屉壳层
+- 为各页面提供新的页面容器
+
+不再把旧 panel 作为最终结构直接塞进抽屉。
+
+### [frontend/public/earth/js/controls.js](/home/ray/dev/linkong/planet/frontend/public/earth/js/controls.js)
+
+职责：
+
+- 管理抽屉开合
+- 管理 tab 切换
+- 管理详情页切入
+- 管理 mobile / desktop 分流
+
+### [frontend/public/earth/js/search.js](/home/ray/dev/linkong/planet/frontend/public/earth/js/search.js)
+
+职责：
+
+- 保留搜索能力和结果逻辑
+- 输出给新的移动端搜索页
+
+### [frontend/public/earth/js/info-card.js](/home/ray/dev/linkong/planet/frontend/public/earth/js/info-card.js)
+
+职责：
+
+- 从桌面 info-card 逻辑中提取可复用的数据层
+- 服务新的移动端详情页
+
+### [frontend/public/earth/js/tv.js](/home/ray/dev/linkong/planet/frontend/public/earth/js/tv.js)
+
+职责：
+
+- 为新的 TV 页面提供数据和状态
+- 不再直接主导移动端媒体 panel 壳层
+
+### [frontend/public/earth/js/news.js](/home/ray/dev/linkong/planet/frontend/public/earth/js/news.js)
+
+职责：
+
+- 为新的新闻页面提供列表和区域焦点数据
+
+### CSS
+
+需要新增真正的移动端页面样式，而不是继续在旧 panel class 上堆条件分支：
+
+- 图层页样式
+- 搜索页样式
+- 态势页样式
+- 新闻页样式
+- TV 页样式
+- 设置页样式
+- 详情页样式
+- 移动端右上角通知 / 胶囊提示样式
+
+## 验收标准
+
+1. `mobile` 模式下不再显示旧 toolbar。
+2. `mobile` 模式下不再把旧 panel 直接作为最终 UI。
+3. 图层、搜索、态势、新闻、TV、设置都是重新设计的移动端页面。
+4. 设置页不再包含移动端无意义的 panel 显示/隐藏项。
+5. 新闻与 TV 已拆分为两个移动端页面。
+6. legend / stats 已整合为态势页。
+7. 详情页成为统一对象详情入口。
+8. 移动端通知栏和胶囊提示已统一放到右上角安全区，而不是屏幕正中。
+
+## 结论
+
+本计划进一步明确：
+
+移动端目标不是“把桌面 HUD 放进抽屉”，而是“以抽屉为载体，重做一套适合手机端的信息页面”。
+
+后续开发必须以此为准：
+
+- 复用数据
+- 重做界面
+- 清除桌面遗留心智
--- a/docs/version-history.md
+++ b/docs/version-history.md
@@ -16,12 +16,16 @@
 ## Current Version

 - `main` 当前主线历史推导到：`0.16.5`
- `dev` 当前开发分支历史推导到：`0.34.0`
+- `dev` 当前开发分支历史推导到：`0.37.0`

 ## Timeline

 | Version | Type | Branch | Commit | Summary |
 | --- | --- | --- | --- | --- |
+| `0.37.0` | feature | `dev` | `pending` | Earth 连线系统从巡航语义中完全解耦为通用 callout connector，统一桌面/移动端对象级锚点、临界区锚点滑动与稳定巡航展示链路 |
+| `0.36.0` | feature | `dev` | `pending` | Earth 新增统一算力中心图层与估算位置展示，继续收口拖拽交互，并补充 AI Provider 指纹与 WSL 局域网访问支撑 |
+| `0.35.1` | bugfix | `dev` | `pending` | 收口 Earth 桌面 HUD 与移动端抽屉的统一统计绑定机制，修复态势统计在图层切换后的同步遗漏 |
+| `0.35.0` | feature | `dev` | `pending` | Earth 移动端抽屉系统与悬浮卡片全面上线：手势驱动抽屉、点击物件弹出可拖动详情卡、单指旋转双指缩放地球 |
 | `0.34.0` | feature | `dev` | `pending` | Earth 搜索面板正式接入，`planet.sh --allow-lan` 打通 Bun + Vite 局域网开放链路，并自动输出推荐访问地址与健康检查地址 |
 | `0.33.0` | feature | `dev` | `pending` | `news_live_streams` 默认接入 iptv-org 频道目录，内置数据源支持直接编辑 override，并修复 TV 合并采集源后默认频道消失的问题 |
 | `0.32.0` | feature | `dev` | `pending` | Earth 设置新增默认地球大小真源，并继续收口卫星焦点层次、toolbar/scrollbar 性能与 HUD 设置面板细节 |
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,6 +1,6 @@
 {
  "name": "planet-frontend",
-  "version": "0.34.0",
+  "version": "0.37.0",
  "private": true,
  "packageManager": "bun@1",
  "dependencies": {
--- a/frontend/public/earth/css/base.css
+++ b/frontend/public/earth/css/base.css
@@ -8,6 +8,10 @@

 :root {
  --hud-scale: 1;
+  --safe-top: env(safe-area-inset-top, 0px);
+  --safe-right: env(safe-area-inset-right, 0px);
+  --safe-bottom: env(safe-area-inset-bottom, 0px);
+  --safe-left: env(safe-area-inset-left, 0px);
  --hud-offset: calc(20px * var(--hud-scale));
  --hud-radius: calc(22px * var(--hud-scale));
  --hud-panel-padding: calc(18px * var(--hud-scale));
@@ -66,12 +70,23 @@ body.earth-page {
  overflow: hidden;
 }

+html.is-globe-dragging,
+body.earth-page.is-globe-dragging,
+body.earth-page.is-globe-dragging * {
+  user-select: none !important;
+  -webkit-user-select: none !important;
+}
+
 .earth-app {
  position: relative;
  width: 100vw;
  height: 100vh;
 }

+.earth-app canvas {
+  touch-action: none;
+}
+
 .earth-app.dragging {
  cursor: grabbing;
 }
--- a/frontend/public/earth/css/earth-stats.css
+++ b/frontend/public/earth/css/earth-stats.css
@@ -133,3 +133,20 @@
  right: var(--hud-offset);
  transform: translate(calc(100% - var(--hud-offset)), calc(-100% + var(--hud-offset)));
 }
+
+.layout-mode-mobile .hud-panel-stats {
+  position: fixed;
+  top: calc(8px + var(--safe-top));
+  right: 8px;
+  width: min(180px, calc(100vw - 16px));
+  z-index: 205;
+}
+
+.layout-mode-mobile.earth-search-open .hud-panel-stats,
+.layout-mode-mobile.earth-settings-open .hud-panel-stats,
+.layout-mode-mobile.earth-media-open .hud-panel-stats,
+.layout-mode-mobile.earth-info-open .hud-panel-stats {
+  opacity: 0;
+  pointer-events: none;
+  transform: translateY(-12px);
+}
--- a/frontend/public/earth/css/hud.css
+++ b/frontend/public/earth/css/hud.css
@@ -117,6 +117,7 @@
 .hud-panel-drag-handle {
  cursor: grab;
  user-select: none;
+  touch-action: none;
 }

 .hud-panel-drag-handle:active {
@@ -260,6 +261,825 @@
  display: none !important;
 }

+/* ── Mobile popup card ───────────────────────────────────────── */
+
+.earth-mobile-popup {
+  display: none;
+}
+
+.layout-mode-mobile .earth-mobile-popup {
+  display: flex;
+  position: fixed;
+  z-index: 260;
+  overflow: visible;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 12px 10px 12px;
+  max-width: 220px;
+  min-width: 120px;
+  background: linear-gradient(145deg, rgba(14, 25, 42, 0.97), rgba(7, 15, 28, 0.97));
+  border: 1px solid rgba(200, 224, 255, 0.13);
+  border-radius: 20px;
+  box-shadow: 0 10px 36px rgba(0, 0, 0, 0.48), 0 0 0 1px rgba(140, 190, 255, 0.05);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  pointer-events: auto;
+  opacity: 0;
+  transform: scale(0.86) translateY(4px);
+  transition: opacity 0.17s ease, transform 0.17s cubic-bezier(0.22, 1, 0.36, 1);
+  cursor: grab;
+  user-select: none;
+  touch-action: none;
+}
+
+.layout-mode-mobile .earth-mobile-popup:active {
+  cursor: grabbing;
+}
+
+.layout-mode-mobile .earth-mobile-popup[hidden] {
+  display: none;
+}
+
+.layout-mode-mobile .earth-mobile-popup.is-visible {
+  opacity: 1;
+  transform: scale(1) translateY(0);
+}
+
+.layout-mode-mobile .earth-mobile-popup.earth-mobile-popup--anchor-stable {
+  transform: none;
+  transition: opacity 0.17s ease;
+}
+
+.layout-mode-mobile .earth-mobile-popup.earth-mobile-popup--anchor-stable.is-visible {
+  transform: none;
+}
+
+.earth-mobile-popup-icon {
+  font-size: 1.25rem;
+  flex-shrink: 0;
+  line-height: 1;
+}
+
+.earth-mobile-popup-body {
+  flex: 1;
+  min-width: 0;
+}
+
+.earth-mobile-popup-title {
+  color: var(--hud-text);
+  font-size: 0.84rem;
+  font-weight: 700;
+  line-height: 1.25;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  letter-spacing: 0.01em;
+}
+
+.earth-mobile-popup-sub {
+  color: var(--hud-text-muted);
+  font-size: 0.70rem;
+  margin-top: 2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  letter-spacing: 0.03em;
+}
+
+.earth-mobile-popup-chevron {
+  color: rgba(160, 200, 255, 0.5);
+  font-size: 1rem;
+  flex-shrink: 0;
+}
+
+.earth-mobile-popup-dock {
+  --earth-mobile-popup-dock-size: 14px;
+  --earth-mobile-popup-dock-offset: calc(var(--earth-mobile-popup-dock-size) * -0.5);
+  position: absolute;
+  top: 32%;
+  width: var(--earth-mobile-popup-dock-size);
+  height: var(--earth-mobile-popup-dock-size);
+  border-radius: 999px;
+  background: transparent;
+  border: 0;
+  box-shadow: none;
+  transform: translateY(-50%);
+  pointer-events: none;
+}
+
+.earth-mobile-popup[data-dock-side="left"] .earth-mobile-popup-dock {
+  left: var(--earth-mobile-popup-dock-offset);
+}
+
+.earth-mobile-popup[data-dock-side="right"] .earth-mobile-popup-dock {
+  right: var(--earth-mobile-popup-dock-offset);
+}
+
+.earth-mobile-popup[data-dock-side="top"] .earth-mobile-popup-dock {
+  top: var(--earth-mobile-popup-dock-offset);
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+.earth-mobile-popup[data-dock-side="bottom"] .earth-mobile-popup-dock {
+  top: auto;
+  bottom: var(--earth-mobile-popup-dock-offset);
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+/* ── Mobile drawer ───────────────────────────────────────────── */
+
+.earth-mobile-drawer-overlay,
+.earth-mobile-drawer-shell {
+  display: none;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-overlay,
+.layout-mode-mobile .earth-mobile-drawer-shell {
+  display: block;
+}
+
+.earth-mobile-drawer-overlay {
+  position: fixed;
+  inset: 0;
+  background: linear-gradient(180deg, rgba(3, 8, 16, 0.06), rgba(3, 8, 16, 0.54));
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity 0.22s ease;
+  z-index: 245;
+}
+
+.earth-mobile-drawer-shell {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 250;
+  pointer-events: none;
+}
+
+.earth-mobile-drawer-sheet {
+  position: relative;
+  min-height: calc(240px + var(--safe-bottom));
+  max-height: min(78vh, calc(100vh - 72px - var(--safe-top)));
+  padding: 10px 14px calc(14px + var(--safe-bottom)) 14px;
+  border-top-left-radius: 28px;
+  border-top-right-radius: 28px;
+  background:
+    linear-gradient(180deg, rgba(15, 27, 43, 0.98), rgba(7, 14, 24, 0.98)),
+    rgba(5, 10, 19, 0.92);
+  border-top: 1px solid rgba(220, 238, 255, 0.1);
+  box-shadow: 0 -26px 60px rgba(0, 0, 0, 0.38);
+  transform: translateY(calc(100% - 36px - var(--safe-bottom)));
+  transition: transform 0.28s cubic-bezier(0.22, 1, 0.36, 1);
+  pointer-events: none;
+  touch-action: none;
+}
+
+.earth-mobile-drawer-header {
+  padding: 10px 4px 8px;
+  cursor: ns-resize;
+  user-select: none;
+  pointer-events: auto;
+}
+
+.earth-mobile-drawer-grabber {
+  width: 54px;
+  height: 5px;
+  margin: 0 auto;
+  border-radius: 999px;
+  background: rgba(225, 239, 255, 0.18);
+}
+
+.earth-mobile-drawer-tabs {
+  display: grid;
+  grid-template-columns: repeat(6, minmax(0, 1fr));
+  gap: 8px;
+  padding-bottom: 12px;
+}
+
+.earth-mobile-drawer-tab {
+  min-height: 40px;
+  border: 1px solid rgba(201, 225, 247, 0.12);
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--hud-text-muted);
+  font-size: 0.78rem;
+  font-weight: 600;
+  letter-spacing: 0.03em;
+  cursor: pointer;
+  transition: background 0.18s ease, border-color 0.18s ease, color 0.18s ease;
+}
+
+.earth-mobile-drawer-tab.is-active {
+  color: var(--hud-title);
+  background: rgba(122, 180, 255, 0.14);
+  border-color: rgba(122, 180, 255, 0.24);
+}
+
+.earth-mobile-drawer-content {
+  position: relative;
+  min-height: 0;
+  max-height: calc(78vh - 108px - var(--safe-bottom));
+  overflow: hidden;
+}
+
+.earth-mobile-drawer-slot {
+  display: none;
+  min-height: 0;
+  max-height: inherit;
+  overflow: auto;
+  overscroll-behavior: contain;
+}
+
+.earth-mobile-drawer-slot.is-active {
+  display: block;
+}
+
+.earth-mobile-drawer-slot--situation {
+  display: none;
+  gap: 12px;
+}
+
+.earth-mobile-drawer-slot--situation.is-active {
+  display: grid;
+}
+
+@keyframes earth-drawer-hint {
+  0%   { transform: translateY(calc(100% - 36px - var(--safe-bottom))); }
+  14%  { transform: translateY(calc(100% - 36px - var(--safe-bottom) - 22px)); }
+  26%  { transform: translateY(calc(100% - 36px - var(--safe-bottom) - 4px)); }
+  38%  { transform: translateY(calc(100% - 36px - var(--safe-bottom) - 14px)); }
+  50%  { transform: translateY(calc(100% - 36px - var(--safe-bottom) - 1px)); }
+  62%  { transform: translateY(calc(100% - 36px - var(--safe-bottom) - 7px)); }
+  76%  { transform: translateY(calc(100% - 36px - var(--safe-bottom))); }
+  100% { transform: translateY(calc(100% - 36px - var(--safe-bottom))); }
+}
+
+.layout-mode-mobile .earth-mobile-drawer-sheet.is-hinting {
+  animation: earth-drawer-hint 0.85s cubic-bezier(0.22, 1, 0.36, 1) forwards;
+}
+
+.layout-mode-mobile.earth-mobile-drawer-open .earth-mobile-drawer-overlay {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.layout-mode-mobile.earth-mobile-drawer-open .earth-mobile-drawer-sheet {
+  transform: translateY(0);
+  pointer-events: auto;
+}
+
+.layout-mode-mobile .earth-left-column {
+  pointer-events: none;
+}
+
+.layout-mode-mobile #brand-panel {
+  pointer-events: auto;
+}
+
+.layout-mode-mobile #search-modal,
+.layout-mode-mobile #settings-modal {
+  display: block;
+  position: static;
+  inset: auto;
+  pointer-events: none;
+}
+
+.layout-mode-mobile #search-backdrop,
+.layout-mode-mobile #settings-backdrop {
+  display: none;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot > .hud-panel,
+.layout-mode-mobile .earth-mobile-drawer-slot > .earth-search-sheet,
+.layout-mode-mobile .earth-mobile-drawer-slot > .earth-settings-sheet {
+  position: relative !important;
+  inset: auto !important;
+  left: auto !important;
+  right: auto !important;
+  top: auto !important;
+  bottom: auto !important;
+  transform: none !important;
+  width: 100% !important;
+  max-width: none !important;
+  min-width: 0 !important;
+  max-height: none !important;
+  height: auto !important;
+  margin: 0;
+  pointer-events: auto;
+  opacity: 1 !important;
+  filter: none !important;
+  visibility: visible !important;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot > .hud-panel {
+  box-shadow: none;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot > .earth-search-sheet {
+  display: flex !important;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot > .earth-settings-sheet {
+  display: flex !important;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot .hud-panel-drag-handle {
+  cursor: default;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot .tv-panel-edge {
+  display: none;
+}
+
+.layout-mode-mobile .earth-mobile-drawer-slot .tv-panel-player {
+  min-height: 220px;
+}
+
+.layout-mode-mobile #layer-toggles,
+.layout-mode-mobile #legend,
+.layout-mode-mobile #earth-stats,
+.layout-mode-mobile #media-panel,
+.layout-mode-mobile #search-modal,
+.layout-mode-mobile #settings-modal,
+.layout-mode-mobile #info-panel {
+  display: none !important;
+}
+
+.earth-mobile-page {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  min-height: 0;
+}
+
+.earth-mobile-page-intro {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.earth-mobile-page-kicker {
+  color: var(--hud-text-muted);
+  font-size: 0.68rem;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.earth-mobile-page-summary {
+  color: var(--hud-text-soft);
+  font-size: 0.84rem;
+  line-height: 1.4;
+}
+
+.earth-mobile-layer-list,
+.earth-mobile-news-board-list,
+.earth-mobile-search-results {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.earth-mobile-layer-card,
+.earth-mobile-action-btn,
+.earth-mobile-settings-pill,
+.earth-mobile-search-clear {
+  appearance: none;
+  -webkit-appearance: none;
+}
+
+.earth-mobile-layer-card {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  width: 100%;
+  border: 1px solid rgba(212, 227, 244, 0.08);
+  border-radius: 18px;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.05), transparent),
+    rgba(255, 255, 255, 0.03);
+  color: var(--hud-text);
+  padding: 14px 16px;
+  text-align: left;
+}
+
+.earth-mobile-layer-card.is-active {
+  border-color: rgba(122, 180, 255, 0.24);
+  background:
+    linear-gradient(180deg, rgba(122, 180, 255, 0.12), transparent),
+    rgba(255, 255, 255, 0.04);
+}
+
+.earth-mobile-layer-card-icon {
+  font-size: 22px;
+  color: var(--hud-accent-strong);
+}
+
+.earth-mobile-layer-card-copy {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  min-width: 0;
+}
+
+.earth-mobile-layer-card-title,
+.earth-mobile-detail-title,
+.earth-mobile-tv-title,
+.earth-mobile-news-focus-label,
+.earth-mobile-settings-label {
+  color: var(--hud-title);
+  font-weight: 600;
+}
+
+.earth-mobile-layer-card-subtitle,
+.earth-mobile-detail-type,
+.earth-mobile-tv-subtitle,
+.earth-mobile-settings-subtitle,
+.earth-mobile-news-focus-coords,
+.earth-mobile-tv-notes,
+.earth-mobile-tv-catalog,
+.earth-mobile-news-board-status,
+.earth-mobile-search-meta,
+.earth-mobile-search-empty {
+  color: var(--hud-text-soft);
+  font-size: 0.76rem;
+  line-height: 1.45;
+}
+
+.earth-mobile-layer-card-status {
+  color: var(--hud-text-muted);
+  font-size: 0.72rem;
+  letter-spacing: 0.08em;
+}
+
+.earth-mobile-search-shell {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 52px;
+  padding: 0 14px;
+  border-radius: 16px;
+  border: 1px solid rgba(214, 230, 247, 0.12);
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.05), transparent),
+    rgba(255, 255, 255, 0.03);
+}
+
+.earth-mobile-search-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  border: 0;
+  background: transparent;
+  color: var(--hud-title);
+  font: inherit;
+  outline: 0;
+}
+
+.earth-mobile-search-input::placeholder {
+  color: rgba(190, 208, 227, 0.46);
+}
+
+.earth-mobile-search-icon {
+  color: var(--hud-text-muted);
+}
+
+.earth-mobile-search-clear {
+  border: 0;
+  background: transparent;
+  color: var(--hud-text-muted);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.earth-mobile-search-clear[hidden] {
+  display: none;
+}
+
+.earth-mobile-stats-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.earth-mobile-stat-card,
+.earth-mobile-situation-card,
+.earth-mobile-news-focus,
+.earth-mobile-settings-card,
+.earth-mobile-detail-card,
+.earth-mobile-tv-meta {
+  border-radius: 18px;
+  border: 1px solid rgba(212, 227, 244, 0.08);
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.05), transparent),
+    rgba(255, 255, 255, 0.03);
+  padding: 14px 16px;
+}
+
+.earth-mobile-stat-card {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.earth-mobile-stat-num {
+  color: var(--hud-title);
+  font-size: 1.26rem;
+  font-weight: 700;
+}
+
+.earth-mobile-stat-label,
+.earth-mobile-situation-card-subtitle,
+.earth-mobile-news-focus-kicker,
+.earth-mobile-settings-title,
+.earth-mobile-tv-status {
+  color: var(--hud-text-muted);
+  font-size: 0.7rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.earth-mobile-situation-card {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.earth-mobile-situation-card-title {
+  color: var(--hud-title);
+  font-size: 0.92rem;
+  font-weight: 600;
+}
+
+.earth-mobile-situation-legend-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.earth-mobile-situation-status {
+  color: var(--hud-text);
+  line-height: 1.5;
+}
+
+.earth-mobile-news-focus,
+.earth-mobile-tv-actions,
+.earth-mobile-news-actions,
+.earth-mobile-settings-actions {
+  display: flex;
+  gap: 10px;
+}
+
+.earth-mobile-news-focus {
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.earth-mobile-news-source-count {
+  color: var(--hud-accent-strong);
+  font-size: 0.74rem;
+  font-weight: 600;
+}
+
+.earth-mobile-news-board-list .news-story-card {
+  margin: 0;
+}
+
+.earth-mobile-news-board-empty[hidden] {
+  display: none;
+}
+
+.earth-mobile-tv-select,
+.earth-mobile-settings-slider {
+  width: 100%;
+}
+
+.earth-mobile-tv-select {
+  border: 1px solid rgba(201, 225, 247, 0.14);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--hud-text);
+  padding: 12px 14px;
+}
+
+.earth-mobile-tv-player {
+  position: relative;
+  min-height: 220px;
+  border-radius: 18px;
+  overflow: hidden;
+  border: 1px solid rgba(201, 225, 247, 0.1);
+  background: linear-gradient(180deg, rgba(9, 18, 32, 0.94), rgba(5, 11, 22, 0.94));
+}
+
+.earth-mobile-tv-empty,
+.earth-mobile-tv-iframe,
+.earth-mobile-tv-video {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.earth-mobile-tv-empty {
+  display: grid;
+  place-items: center;
+  padding: 16px;
+  text-align: center;
+  color: var(--hud-text-muted);
+}
+
+.earth-mobile-tv-iframe,
+.earth-mobile-tv-video {
+  border: 0;
+  background: #050a14;
+}
+
+.earth-mobile-action-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 42px;
+  padding: 0 14px;
+  border-radius: 12px;
+  border: 1px solid rgba(122, 180, 255, 0.22);
+  background: rgba(122, 180, 255, 0.12);
+  color: var(--hud-title);
+  text-decoration: none;
+  font-size: 0.82rem;
+  font-weight: 600;
+}
+
+.earth-mobile-action-btn--ghost {
+  background: rgba(255, 255, 255, 0.04);
+  border-color: rgba(212, 227, 244, 0.1);
+}
+
+.earth-mobile-settings-group {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.earth-mobile-settings-card {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.earth-mobile-settings-card--stacked {
+  flex-direction: column;
+  align-items: stretch;
+}
+
+.earth-mobile-settings-copy {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.earth-mobile-settings-segmented {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.earth-mobile-settings-pill {
+  border: 1px solid rgba(212, 227, 244, 0.1);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--hud-text-soft);
+  padding: 10px 14px;
+}
+
+.earth-mobile-settings-pill.is-active {
+  color: var(--hud-title);
+  border-color: rgba(122, 180, 255, 0.24);
+  background: rgba(122, 180, 255, 0.14);
+}
+
+.earth-mobile-settings-switch {
+  position: relative;
+  display: inline-flex;
+  width: 44px;
+  height: 28px;
+  flex-shrink: 0;
+}
+
+.earth-mobile-settings-switch input {
+  position: absolute;
+  inset: 0;
+  opacity: 0;
+}
+
+.earth-mobile-settings-switch-track {
+  width: 100%;
+  height: 100%;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.1);
+  position: relative;
+}
+
+.earth-mobile-settings-switch-track::after {
+  content: "";
+  position: absolute;
+  top: 4px;
+  left: 4px;
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  background: #fff;
+  transition: transform 0.18s ease;
+}
+
+.earth-mobile-settings-switch input:checked + .earth-mobile-settings-switch-track {
+  background: rgba(122, 180, 255, 0.34);
+}
+
+.earth-mobile-settings-switch input:checked + .earth-mobile-settings-switch-track::after {
+  transform: translateX(16px);
+}
+
+.earth-mobile-settings-slider-row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.earth-mobile-settings-slider-value {
+  color: var(--hud-title);
+  font-weight: 600;
+}
+
+.earth-mobile-detail-card {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.earth-mobile-detail-header {
+  display: flex;
+  gap: 12px;
+  align-items: center;
+}
+
+.earth-mobile-detail-icon {
+  font-size: 1.5rem;
+}
+
+.earth-mobile-detail-heading {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.earth-mobile-detail-content {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.earth-mobile-detail-row {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+}
+
+.earth-mobile-detail-row-label {
+  color: var(--hud-text-muted);
+  font-size: 0.72rem;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.earth-mobile-detail-row-value,
+.earth-mobile-detail-empty {
+  color: var(--hud-text);
+  line-height: 1.5;
+}
+
+.layout-mode-mobile .earth-status-message,
+.layout-mode-mobile .earth-error-message {
+  top: calc(var(--safe-top) + 130px);
+  left: auto;
+  right: calc(8px + var(--safe-right));
+  transform: translate(0, -10px);
+  min-width: 0;
+  max-width: min(200px, 52vw);
+  font-size: 0.78rem;
+  padding: 6px 14px 6px 10px;
+}
+
+.layout-mode-mobile .earth-status-message.visible,
+.layout-mode-mobile .earth-error-message.visible {
+  transform: translate(0, 0);
+}
+
 .hud-panel-row {
  display: flex;
  justify-content: space-between;
@@ -1110,6 +1930,30 @@
  }
 }

+.layout-mode-mobile .earth-search-sheet {
+  top: calc(8px + var(--safe-top));
+  left: 8px;
+  right: 8px;
+  width: auto;
+  max-height: calc(100vh - var(--safe-top) - var(--safe-bottom) - 16px);
+  transform: translateX(0) translateY(8px) scale(1);
+}
+
+.layout-mode-mobile .earth-search-modal.is-open .earth-search-sheet {
+  transform: translateX(0) translateY(0) scale(1);
+}
+
+.layout-mode-mobile .earth-settings-sheet {
+  top: auto;
+  left: 8px;
+  right: 8px;
+  bottom: calc(8px + var(--safe-bottom));
+  width: auto;
+  max-width: none;
+  max-height: min(78vh, 720px);
+  border-radius: 24px 24px 18px 18px;
+}
+
 /* .earth-left-column layout-expanded rule lives in info-panel.css */
 /* .hud-panel-legend layout-expanded rule lives in legend.css */
 /* .hud-panel-stats layout-expanded rule lives in earth-stats.css */
--- a/frontend/public/earth/css/info-panel.css
+++ b/frontend/public/earth/css/info-panel.css
@@ -153,15 +153,28 @@
  transition:
    opacity 0.22s ease,
    transform 0.22s ease;
+  visibility: hidden;
+  user-select: none;
+  -webkit-user-select: none;
 }

 .hud-panel-info.is-visible {
  opacity: 1;
  transform: scale(1) translateY(0);
  pointer-events: auto;
+  visibility: visible;
 }

-.info-card-cruise-link {
+.hud-panel-info.hud-panel-info--anchor-stable {
+  transform: none;
+  transition: opacity 0.22s ease;
+}
+
+.hud-panel-info.hud-panel-info--anchor-stable.is-visible {
+  transform: none;
+}
+
+.callout-connector {
  position: absolute;
  inset: 0;
  width: 100%;
@@ -173,7 +186,7 @@
  z-index: 49;
 }

-.info-card-cruise-link polyline {
+.callout-connector polyline {
  fill: none;
  stroke: rgba(255, 255, 255, 0.98);
  stroke-width: 2.15;
@@ -185,7 +198,7 @@
    drop-shadow(0 0 6px rgba(8, 20, 36, 0.1));
 }

-.info-card-cruise-link circle {
+.callout-connector circle {
  fill: rgba(255, 255, 255, 0.98);
  stroke: rgba(7, 16, 32, 0.72);
  stroke-width: 1.0;
@@ -197,29 +210,29 @@
  transform-origin: center;
 }

-.info-card-cruise-link.is-visible {
+.callout-connector.is-visible {
  opacity: 1;
 }

-.info-card-cruise-link.is-animating polyline {
-  animation: cruiseConnectorDraw 0.42s cubic-bezier(0.22, 1, 0.36, 1) forwards;
+.callout-connector.is-animating polyline {
+  animation: calloutConnectorDraw 0.42s cubic-bezier(0.22, 1, 0.36, 1) forwards;
 }

-.info-card-cruise-link.is-animating circle {
+.callout-connector.is-animating circle {
  opacity: 0;
 }

-.info-card-cruise-link.is-animating circle:first-of-type {
-  animation: cruiseConnectorNodeIn 0.14s ease forwards;
+.callout-connector.is-animating circle:first-of-type {
+  animation: calloutConnectorNodeIn 0.14s ease forwards;
  animation-delay: 0.02s;
 }

-.info-card-cruise-link.is-animating circle:last-of-type {
-  animation: cruiseConnectorNodeIn 0.16s ease forwards;
+.callout-connector.is-animating circle:last-of-type {
+  animation: calloutConnectorNodeIn 0.16s ease forwards;
  animation-delay: 0.34s;
 }

-@keyframes cruiseConnectorDraw {
+@keyframes calloutConnectorDraw {
  from {
    stroke-dashoffset: var(--connector-length, 0px);
  }
@@ -228,7 +241,7 @@
  }
 }

-@keyframes cruiseConnectorNodeIn {
+@keyframes calloutConnectorNodeIn {
  from {
    opacity: 0;
    transform: scale(0.72);
@@ -290,6 +303,8 @@
  scrollbar-width: thin;
  scrollbar-color: rgba(160, 186, 216, 0.34) transparent;
  pointer-events: auto;
+  user-select: none;
+  -webkit-user-select: none;
 }

 .info-card-content::-webkit-scrollbar {
@@ -327,6 +342,8 @@
  cursor: pointer;
  flex-shrink: 0;
  transition: color 0.18s ease;
+  user-select: none;
+  -webkit-user-select: none;
 }

 .info-card-label:hover {
@@ -341,6 +358,8 @@
  text-align: right;
  max-width: calc(180px * var(--hud-scale));
  word-break: break-word;
+  user-select: none;
+  -webkit-user-select: none;
 }

 /* Type-specific header accent colors */
@@ -367,3 +386,39 @@
 .earth-app.layout-expanded .earth-left-column {
  transform: translate(calc(-100% + var(--hud-offset)), 0);
 }
+
+.layout-mode-mobile .earth-left-column {
+  top: calc(8px + var(--safe-top));
+  left: 8px;
+  max-width: min(300px, calc(100vw - 16px));
+}
+
+.layout-mode-mobile .hud-panel-info {
+  position: fixed;
+  left: 8px !important;
+  right: 8px !important;
+  top: auto !important;
+  bottom: calc(84px + var(--safe-bottom)) !important;
+  width: auto;
+  max-width: none;
+  max-height: min(58vh, 520px);
+  z-index: 240;
+}
+
+.layout-mode-mobile .info-card-header {
+  cursor: default;
+}
+
+.layout-mode-mobile .info-card-content {
+  max-height: min(46vh, 420px);
+}
+
+.layout-mode-mobile .info-card-property {
+  flex-direction: column;
+  align-items: stretch;
+}
+
+.layout-mode-mobile .info-card-value {
+  max-width: none;
+  text-align: left;
+}
--- a/frontend/public/earth/css/layer-panel.css
+++ b/frontend/public/earth/css/layer-panel.css
@@ -160,6 +160,23 @@
 .layer-panel-list {
  display: flex;
  flex-direction: column;
+  max-height: calc(5 * (56px * var(--hud-scale)));
+  overflow-y: auto;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(160, 186, 216, 0.34) transparent;
+}
+
+.layer-panel-list::-webkit-scrollbar {
+  width: 4px;
+}
+
+.layer-panel-list::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.layer-panel-list::-webkit-scrollbar-thumb {
+  background: linear-gradient(180deg, rgba(210, 225, 242, 0.2), rgba(126, 154, 185, 0.28));
+  border-radius: 999px;
 }

 .layer-row {
@@ -169,6 +186,7 @@
  padding: calc(9px * var(--hud-scale)) calc(10px * var(--hud-scale));
  border-bottom: 1px solid var(--hud-line);
  transition: background 0.14s ease;
+  min-height: calc(56px * var(--hud-scale));
 }

 .layer-row:last-child {
@@ -317,3 +335,34 @@

 /* Layout-expanded: layer panel slides off with .earth-left-column — no
   individual rule needed since the whole column translates together. */
+
+.layout-mode-mobile .hud-panel-layers {
+  position: fixed;
+  left: 12px;
+  right: 12px;
+  bottom: calc(88px + var(--safe-bottom));
+  width: auto;
+  max-height: min(60vh, 520px);
+  margin-top: 0;
+  z-index: 220;
+  transform: translateY(calc(100% + 28px));
+  opacity: 0;
+  pointer-events: none;
+  transition: transform 0.24s ease, opacity 0.2s ease;
+}
+
+.layout-mode-mobile .hud-panel-layers.is-mobile-open {
+  transform: translateY(0);
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.layout-mode-mobile .layer-panel-body {
+  max-height: min(52vh, 460px);
+  overflow: auto;
+}
+
+.layout-mode-mobile .layer-panel-list {
+  max-height: none;
+  overflow-y: visible;
+}
--- a/frontend/public/earth/css/legend.css
+++ b/frontend/public/earth/css/legend.css
@@ -138,3 +138,24 @@
  bottom: var(--hud-offset);
  transform: translate(calc(-100% + var(--hud-offset)), calc(100% - var(--hud-offset)));
 }
+
+.layout-mode-mobile .hud-panel-legend {
+  position: fixed;
+  left: 8px;
+  bottom: calc(84px + var(--safe-bottom));
+  width: min(172px, calc(100vw - 16px));
+  z-index: 205;
+}
+
+.layout-mode-mobile .legend-list {
+  max-height: min(20vh, 180px);
+}
+
+.layout-mode-mobile.earth-search-open .hud-panel-legend,
+.layout-mode-mobile.earth-settings-open .hud-panel-legend,
+.layout-mode-mobile.earth-media-open .hud-panel-legend,
+.layout-mode-mobile.earth-info-open .hud-panel-legend {
+  opacity: 0;
+  pointer-events: none;
+  transform: translateY(12px);
+}
--- a/frontend/public/earth/css/toolbar.css
+++ b/frontend/public/earth/css/toolbar.css
@@ -105,6 +105,14 @@
  pointer-events: auto;
 }

+.earth-toolbar-orb:has(#layer-action) {
+  display: none;
+}
+
+.layout-mode-mobile .earth-toolbar-group {
+  display: none;
+}
+
 .earth-toolbar-cluster.is-collapsed .earth-toolbar-orb > * {
  pointer-events: none;
 }
--- a/frontend/public/earth/css/tv-panel.css
+++ b/frontend/public/earth/css/tv-panel.css
@@ -285,6 +285,27 @@
  cursor: nesw-resize;
 }

+.layout-mode-mobile .hud-panel-media {
+  position: fixed;
+  left: 8px;
+  right: 8px;
+  top: calc(8px + var(--safe-top));
+  bottom: calc(84px + var(--safe-bottom));
+  width: auto;
+  max-width: none;
+  max-height: none;
+  min-width: 0;
+  z-index: 230;
+}
+
+.layout-mode-mobile .tv-panel-player {
+  min-height: min(42vh, 360px);
+}
+
+.layout-mode-mobile .tv-panel-edge {
+  display: none;
+}
+
 /* 右下角视觉标记 */
 .tv-panel-edge[data-edge="br"]::before {
  content: "";
--- a/frontend/public/earth/index.html
+++ b/frontend/public/earth/index.html
@@ -16,6 +16,22 @@
  }
  </script>
  <script>
+    (function applyInitialEarthViewportMode() {
+      var width = window.innerWidth;
+      var height = window.innerHeight;
+      var mode = "desktop";
+
+      if (width <= 820) {
+        mode = "mobile";
+      } else if (width <= 1080 || height <= 760) {
+        mode = "compact";
+      }
+
+      document.documentElement.classList.toggle("layout-mode-mobile", mode === "mobile");
+      document.documentElement.classList.toggle("layout-mode-compact", mode === "compact");
+      document.documentElement.dataset.earthLayoutMode = mode;
+    })();
+
    (function applyInitialHudScale() {
      var referenceWidth = 1920;
      var referenceHeight = 1080;
@@ -132,6 +148,16 @@
                <span class="layer-row-toggle-track"></span>
              </button>
            </div>
+            <div class="layer-row" data-layer-name="算力中心 compute centers">
+              <span class="material-symbols-rounded layer-row-icon">memory</span>
+              <div class="layer-row-copy">
+                <span class="layer-row-label">算力中心</span>
+                <span class="layer-row-meta">Compute Centers</span>
+              </div>
+              <button id="toggle-compute-centers" class="layer-row-toggle active" type="button" role="switch" aria-checked="true" title="切换算力中心显示">
+                <span class="layer-row-toggle-track"></span>
+              </button>
+            </div>
            <div class="layer-row" data-layer-name="bgp观测 routing signals">
              <span class="material-symbols-rounded layer-row-icon">hub</span>
              <div class="layer-row-copy">
@@ -156,6 +182,14 @@
      <div id="control-toolbar" class="earth-toolbar">
        <div id="toolbar-cluster" class="earth-toolbar-cluster is-collapsed">
          <div class="earth-toolbar-orb" data-orb-index="0" style="--orb-delay: 0s;">
+            <button id="layer-action" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="图层">
+              <span class="icon" aria-hidden="true">
+                <span class="material-symbols-rounded">layers</span>
+              </span>
+              <span class="tooltip earth-toolbar-tooltip">图层</span>
+            </button>
+          </div>
+          <div class="earth-toolbar-orb" data-orb-index="1" style="--orb-delay: 0.12s;">
            <button id="search-action" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="搜索">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">search</span>
@@ -163,7 +197,7 @@
              <span class="tooltip earth-toolbar-tooltip">搜索</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="1" style="--orb-delay: 0.18s;">
+          <div class="earth-toolbar-orb" data-orb-index="2" style="--orb-delay: 0.24s;">
            <button id="rotate-toggle" class="floating-btn liquid-glass-surface earth-toolbar-btn earth-rotate-toggle" title="自动旋转">
              <span class="icon rotate-icon icon-pause" aria-hidden="true">
                <span class="material-symbols-rounded">pause</span>
@@ -174,7 +208,7 @@
              <span class="tooltip earth-toolbar-tooltip">自动旋转</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="2" style="--orb-delay: 0.36s;">
+          <div class="earth-toolbar-orb" data-orb-index="3" style="--orb-delay: 0.36s;">
            <button id="toggle-tv" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="新闻直播">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">live_tv</span>
@@ -182,7 +216,7 @@
              <span class="tooltip earth-toolbar-tooltip">打开媒体面板</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="3" style="--orb-delay: 0.54s;">
+          <div class="earth-toolbar-orb" data-orb-index="4" style="--orb-delay: 0.54s;">
            <button id="reload-data" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="重新加载数据">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">refresh</span>
@@ -190,7 +224,7 @@
              <span class="tooltip earth-toolbar-tooltip">重新加载数据</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb earth-toolbar-popover earth-zoom-group" id="zoom-control-group" data-orb-index="4" style="--orb-delay: 0.72s;">
+          <div class="earth-toolbar-orb earth-toolbar-popover earth-zoom-group" id="zoom-control-group" data-orb-index="5" style="--orb-delay: 0.72s;">
            <button id="zoom-trigger" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="缩放控制">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">zoom_in</span>
@@ -203,7 +237,7 @@
              <button id="zoom-out" class="liquid-glass-surface earth-zoom-btn" title="缩小" aria-label="缩小"><span aria-hidden="true">−</span></button>
            </div>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="5" style="--orb-delay: 0.9s;">
+          <div class="earth-toolbar-orb" data-orb-index="6" style="--orb-delay: 0.9s;">
            <button id="settings-trigger" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="设置">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">settings</span>
@@ -211,7 +245,7 @@
              <span class="tooltip earth-toolbar-tooltip">设置</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="6" style="--orb-delay: 1.08s;">
+          <div class="earth-toolbar-orb" data-orb-index="7" style="--orb-delay: 1.08s;">
            <button id="reset-view" class="floating-btn liquid-glass-surface earth-toolbar-btn" title="重置视角">
              <span class="icon" aria-hidden="true">
                <span class="material-symbols-rounded">my_location</span>
@@ -219,7 +253,7 @@
              <span class="tooltip earth-toolbar-tooltip">重置视角</span>
            </button>
          </div>
-          <div class="earth-toolbar-orb" data-orb-index="7" style="--orb-delay: 1.26s;">
+          <div class="earth-toolbar-orb" data-orb-index="8" style="--orb-delay: 1.26s;">
            <button id="layout-toggle" class="floating-btn liquid-glass-surface earth-toolbar-btn earth-layout-toggle" title="最大化布局">
              <span class="icon layout-icon layout-expand" aria-hidden="true">
                <span class="material-symbols-rounded">open_in_full</span>
@@ -274,23 +308,27 @@
      <!-- 2-col KPI grid -->
      <div class="stats-grid">
        <div class="stat-cell">
-          <span class="stat-num" id="cable-count">—</span>
+          <span class="stat-num" id="cable-count" data-earth-stat="cable-count">—</span>
          <span class="stat-label">海缆系统</span>
        </div>
        <div class="stat-cell">
-          <span class="stat-num" id="landing-point-count">—</span>
+          <span class="stat-num" id="landing-point-count" data-earth-stat="landing-point-count">—</span>
          <span class="stat-label">登陆点</span>
        </div>
        <div class="stat-cell">
-          <span class="stat-num" id="satellite-count">—</span>
+          <span class="stat-num" id="satellite-count" data-earth-stat="satellite-count">—</span>
          <span class="stat-label">在轨卫星</span>
        </div>
        <div class="stat-cell">
-          <span class="stat-num" id="bgp-anomaly-count">—</span>
+          <span class="stat-num" id="compute-center-count" data-earth-stat="compute-center-count">—</span>
+          <span class="stat-label">算力中心</span>
+        </div>
+        <div class="stat-cell">
+          <span class="stat-num" id="bgp-anomaly-count" data-earth-stat="bgp-anomaly-count">—</span>
          <span class="stat-label">BGP 事件</span>
        </div>
        <div class="stat-cell">
-          <span class="stat-num" id="bgp-collector-count">—</span>
+          <span class="stat-num" id="bgp-collector-count" data-earth-stat="bgp-collector-count">—</span>
          <span class="stat-label">BGP 观测站</span>
        </div>
        <div class="stat-cell">
@@ -302,12 +340,12 @@
      <!-- BGP status footer -->
      <div class="stats-footer">
        <span class="stats-footer-dot"></span>
-        <span id="bgp-status-summary" class="stats-footer-text">暂无观测数据</span>
+        <span id="bgp-status-summary" class="stats-footer-text" data-earth-stat="bgp-status-summary">暂无观测数据</span>
      </div>

      <!-- hidden elements kept for JS compatibility -->
-      <span id="terrain-status" hidden></span>
-      <span id="texture-quality" hidden></span>
+      <span id="terrain-status" data-earth-stat="terrain-status" hidden></span>
+      <span id="texture-quality" data-earth-stat="texture-quality" hidden></span>
      <span id="camera-distance" hidden></span>
    </div>

@@ -412,6 +450,265 @@

    <div id="status-message" class="earth-status-message" aria-live="polite" aria-atomic="true"></div>
    <div id="tooltip" class="earth-tooltip"></div>
+    <div id="earth-mobile-popup" class="earth-mobile-popup" hidden aria-live="polite">
+      <span id="earth-mobile-popup-dock" class="earth-mobile-popup-dock" aria-hidden="true"></span>
+      <span class="earth-mobile-popup-icon" id="earth-mobile-popup-icon"></span>
+      <div class="earth-mobile-popup-body">
+        <div class="earth-mobile-popup-title" id="earth-mobile-popup-title"></div>
+        <div class="earth-mobile-popup-sub" id="earth-mobile-popup-sub"></div>
+      </div>
+      <span class="material-symbols-rounded earth-mobile-popup-chevron">chevron_right</span>
+    </div>
+    <div id="mobile-drawer-overlay" class="earth-mobile-drawer-overlay" hidden></div>
+    <div id="mobile-drawer-shell" class="earth-mobile-drawer-shell" aria-hidden="true">
+      <div class="earth-mobile-drawer-sheet">
+        <div id="mobile-drawer-handle" class="earth-mobile-drawer-header">
+          <div class="earth-mobile-drawer-grabber" aria-hidden="true"></div>
+        </div>
+        <div class="earth-mobile-drawer-tabs" role="tablist" aria-label="移动端菜单">
+          <button class="earth-mobile-drawer-tab is-active" type="button" role="tab" data-drawer-card="layers" aria-selected="true">图层</button>
+          <button class="earth-mobile-drawer-tab" type="button" role="tab" data-drawer-card="search" aria-selected="false">搜索</button>
+          <button class="earth-mobile-drawer-tab" type="button" role="tab" data-drawer-card="situation" aria-selected="false">态势</button>
+          <button class="earth-mobile-drawer-tab" type="button" role="tab" data-drawer-card="news" aria-selected="false">新闻</button>
+          <button class="earth-mobile-drawer-tab" type="button" role="tab" data-drawer-card="tv" aria-selected="false">TV</button>
+          <button class="earth-mobile-drawer-tab" type="button" role="tab" data-drawer-card="settings" aria-selected="false">设置</button>
+        </div>
+        <div class="earth-mobile-drawer-content">
+          <section class="earth-mobile-drawer-slot is-active" data-drawer-slot="layers">
+            <div class="earth-mobile-page earth-mobile-page--layers">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">Layer Control</span>
+                <span id="mobile-layer-summary" class="earth-mobile-page-summary">已启用 0 个图层</span>
+              </div>
+              <div id="mobile-layer-list" class="earth-mobile-layer-list"></div>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot" data-drawer-slot="search">
+            <div class="earth-mobile-page earth-mobile-page--search">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">Object Search</span>
+                <span class="earth-mobile-page-summary">搜索海缆、登陆点、卫星、算力中心和 BGP 事件</span>
+              </div>
+              <div class="earth-mobile-search-shell">
+                <span class="material-symbols-rounded earth-mobile-search-icon" aria-hidden="true">search</span>
+                <input
+                  id="mobile-earth-search-input"
+                  class="earth-mobile-search-input"
+                  type="text"
+                  inputmode="search"
+                  autocomplete="off"
+                  spellcheck="false"
+                  placeholder="输入名称、地点、NORAD、ASN..."
+                >
+                <button id="mobile-earth-search-clear" class="earth-mobile-search-clear" type="button" aria-label="清除搜索" hidden>
+                  <span class="material-symbols-rounded">close</span>
+                </button>
+              </div>
+              <div id="mobile-earth-search-meta" class="earth-mobile-search-meta">输入关键词以搜索当前地球对象</div>
+              <div id="mobile-earth-search-results" class="earth-mobile-search-results" role="listbox" aria-label="移动端搜索结果"></div>
+              <div id="mobile-earth-search-empty" class="earth-mobile-search-empty">支持搜索海缆、登陆点、卫星、算力中心、BGP 事件与观测站。</div>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot earth-mobile-drawer-slot--situation" data-drawer-slot="situation">
+            <div class="earth-mobile-page earth-mobile-page--situation">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">Situation</span>
+                <span class="earth-mobile-page-summary">面向移动端整合的全球态势概览</span>
+              </div>
+              <div class="earth-mobile-stats-grid">
+                <div class="earth-mobile-stat-card">
+                  <span id="mobile-cable-count" class="earth-mobile-stat-num" data-earth-stat="cable-count">—</span>
+                  <span class="earth-mobile-stat-label">海缆系统</span>
+                </div>
+                <div class="earth-mobile-stat-card">
+                  <span id="mobile-landing-point-count" class="earth-mobile-stat-num" data-earth-stat="landing-point-count">—</span>
+                  <span class="earth-mobile-stat-label">登陆点</span>
+                </div>
+                <div class="earth-mobile-stat-card">
+                  <span id="mobile-satellite-count" class="earth-mobile-stat-num" data-earth-stat="satellite-count">—</span>
+                  <span class="earth-mobile-stat-label">在轨卫星</span>
+                </div>
+                <div class="earth-mobile-stat-card">
+                  <span id="mobile-compute-center-count" class="earth-mobile-stat-num" data-earth-stat="compute-center-count">—</span>
+                  <span class="earth-mobile-stat-label">算力中心</span>
+                </div>
+                <div class="earth-mobile-stat-card">
+                  <span id="mobile-bgp-anomaly-count" class="earth-mobile-stat-num" data-earth-stat="bgp-anomaly-count">—</span>
+                  <span class="earth-mobile-stat-label">BGP 事件</span>
+                </div>
+              </div>
+              <div class="earth-mobile-situation-card">
+                <div class="earth-mobile-situation-card-title">图例</div>
+                <div id="mobile-situation-legend-mode" class="earth-mobile-situation-card-subtitle">海缆</div>
+                <div id="mobile-situation-legend-list" class="earth-mobile-situation-legend-list"></div>
+              </div>
+              <div class="earth-mobile-situation-card">
+                <div class="earth-mobile-situation-card-title">BGP 状态</div>
+                <div id="mobile-bgp-status-summary" class="earth-mobile-situation-status" data-earth-stat="bgp-status-summary">暂无观测数据</div>
+              </div>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot" data-drawer-slot="news">
+            <div class="earth-mobile-page earth-mobile-page--news">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">News</span>
+                <span class="earth-mobile-page-summary">跟随当前视角聚焦全球区域新闻</span>
+              </div>
+              <div class="earth-mobile-news-focus">
+                <div>
+                  <div class="earth-mobile-news-focus-kicker">当前关注区域</div>
+                  <div id="mobile-news-focus-label" class="earth-mobile-news-focus-label">全球焦点</div>
+                  <div id="mobile-news-focus-coords" class="earth-mobile-news-focus-coords">跟随当前视角自动聚焦</div>
+                </div>
+                <div id="mobile-news-source-count" class="earth-mobile-news-source-count">0 路聚合源</div>
+              </div>
+              <div id="mobile-news-board-status" class="earth-mobile-news-board-status">正在准备全球态势新闻...</div>
+              <div id="mobile-news-board-list" class="earth-mobile-news-board-list"></div>
+              <div id="mobile-news-board-empty" class="earth-mobile-news-board-empty" hidden>正在准备全球态势新闻聚合源...</div>
+              <div class="earth-mobile-news-actions">
+                <button id="mobile-news-refresh" class="earth-mobile-action-btn" type="button">刷新</button>
+                <button id="mobile-news-open-external" class="earth-mobile-action-btn" type="button">打开源站</button>
+              </div>
+              <a id="mobile-news-feed-anchor" hidden rel="noreferrer noopener" target="_blank"></a>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot" data-drawer-slot="tv">
+            <div class="earth-mobile-page earth-mobile-page--tv">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">TV</span>
+                <span class="earth-mobile-page-summary">移动端新闻直播和频道切换</span>
+              </div>
+              <select id="mobile-tv-source-select" class="earth-mobile-tv-select" aria-label="选择移动端新闻直播源"></select>
+              <div class="earth-mobile-tv-meta">
+                <span id="mobile-tv-source-status" class="earth-mobile-tv-status">等待加载直播源</span>
+                <div id="mobile-tv-source-title" class="earth-mobile-tv-title">暂无可用频道</div>
+                <div id="mobile-tv-source-meta" class="earth-mobile-tv-subtitle">当前未配置可播放新闻直播源</div>
+                <div id="mobile-tv-source-catalog" class="earth-mobile-tv-catalog">频道目录待同步</div>
+                <div id="mobile-tv-source-notes" class="earth-mobile-tv-notes">支持后台配置默认源与采集器补充源。</div>
+              </div>
+              <div class="earth-mobile-tv-player">
+                <div id="mobile-tv-empty-state" class="earth-mobile-tv-empty">暂无可播放直播源，请先在系统配置中添加频道。</div>
+                <iframe
+                  id="mobile-tv-iframe"
+                  class="earth-mobile-tv-iframe"
+                  hidden
+                  title="移动端新闻直播"
+                  referrerpolicy="strict-origin-when-cross-origin"
+                  allow="autoplay; fullscreen; picture-in-picture"
+                ></iframe>
+                <video id="mobile-tv-video" class="earth-mobile-tv-video" hidden controls autoplay muted playsinline></video>
+              </div>
+              <div class="earth-mobile-tv-actions">
+                <button id="mobile-tv-refresh" class="earth-mobile-action-btn" type="button">刷新</button>
+                <button id="mobile-tv-open-external" class="earth-mobile-action-btn" type="button">访问官网</button>
+              </div>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot" data-drawer-slot="settings">
+            <div class="earth-mobile-page earth-mobile-page--settings">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">Settings</span>
+                <span class="earth-mobile-page-summary">仅保留移动端仍有意义的 Earth 配置</span>
+              </div>
+              <div class="earth-mobile-settings-group">
+                <div class="earth-mobile-settings-title">旋转</div>
+                <div class="earth-mobile-settings-card earth-mobile-settings-card--stacked">
+                  <div class="earth-mobile-settings-copy">
+                    <span class="earth-mobile-settings-label">旋转模式</span>
+                    <span class="earth-mobile-settings-subtitle">巡航模式会按 BGP 事件轮播聚焦</span>
+                  </div>
+                  <div class="earth-mobile-settings-segmented" role="group" aria-label="移动端选择旋转模式">
+                    <button type="button" class="earth-mobile-settings-pill is-active" data-rotation-mode="rotate" aria-pressed="true">旋转模式</button>
+                    <button type="button" class="earth-mobile-settings-pill" data-rotation-mode="cruise" aria-pressed="false">巡航模式</button>
+                  </div>
+                </div>
+              </div>
+              <div class="earth-mobile-settings-group">
+                <div class="earth-mobile-settings-title">视图</div>
+                <label class="earth-mobile-settings-card">
+                  <div class="earth-mobile-settings-copy">
+                    <span class="earth-mobile-settings-label">日夜模式</span>
+                    <span class="earth-mobile-settings-subtitle">按真实太阳位置区分地球昼夜明暗</span>
+                  </div>
+                  <span class="earth-mobile-settings-switch">
+                    <input type="checkbox" data-daynight-toggle checked>
+                    <span class="earth-mobile-settings-switch-track"></span>
+                  </span>
+                </label>
+                <div class="earth-mobile-settings-card earth-mobile-settings-card--stacked">
+                  <div class="earth-mobile-settings-copy">
+                    <span class="earth-mobile-settings-label">地球默认大小</span>
+                    <span class="earth-mobile-settings-subtitle">用于重置视角、缩放重置和巡航视图</span>
+                  </div>
+                  <div class="earth-mobile-settings-slider-row">
+                    <input
+                      class="earth-mobile-settings-slider"
+                      type="range"
+                      min="0.5"
+                      max="5"
+                      step="0.01"
+                      value="1"
+                      data-default-earth-size-slider
+                      aria-label="移动端调整地球默认大小"
+                    >
+                    <span class="earth-mobile-settings-slider-value" data-default-earth-size-value>100%</span>
+                  </div>
+                </div>
+              </div>
+              <div class="earth-mobile-settings-group">
+                <div class="earth-mobile-settings-title">地形</div>
+                <div class="earth-mobile-settings-card earth-mobile-settings-card--stacked">
+                  <div class="earth-mobile-settings-copy">
+                    <span class="earth-mobile-settings-label">地形透明度</span>
+                    <span class="earth-mobile-settings-subtitle">调高后会呈现更明显的绿色地形覆盖效果</span>
+                  </div>
+                  <div class="earth-mobile-settings-slider-row">
+                    <input
+                      class="earth-mobile-settings-slider"
+                      type="range"
+                      min="0.05"
+                      max="1"
+                      step="0.01"
+                      value="0.62"
+                      data-terrain-opacity-slider
+                      aria-label="移动端调整地形透明度"
+                    >
+                    <span class="earth-mobile-settings-slider-value" data-terrain-opacity-value>62%</span>
+                  </div>
+                </div>
+              </div>
+              <div class="earth-mobile-settings-group">
+                <div class="earth-mobile-settings-title">系统</div>
+                <div class="earth-mobile-settings-actions">
+                  <button id="mobile-settings-reset" class="earth-mobile-action-btn earth-mobile-action-btn--ghost" type="button">重置设置</button>
+                  <a class="earth-mobile-action-btn" href="/admin" target="_blank" rel="noreferrer noopener">打开 Admin</a>
+                </div>
+              </div>
+            </div>
+          </section>
+          <section class="earth-mobile-drawer-slot" data-drawer-slot="details">
+            <div class="earth-mobile-page earth-mobile-page--details">
+              <div class="earth-mobile-page-intro">
+                <span class="earth-mobile-page-kicker">Details</span>
+                <span class="earth-mobile-page-summary">点击地球对象后查看统一详情</span>
+              </div>
+              <div class="earth-mobile-detail-card">
+                <div class="earth-mobile-detail-header">
+                  <span id="mobile-info-card-icon" class="earth-mobile-detail-icon">🛰️</span>
+                  <div class="earth-mobile-detail-heading">
+                    <div id="mobile-info-card-title" class="earth-mobile-detail-title">对象详情</div>
+                    <div id="mobile-info-card-type" class="earth-mobile-detail-type">等待选择对象</div>
+                  </div>
+                </div>
+                <div id="mobile-info-card-content" class="earth-mobile-detail-content">
+                  <div class="earth-mobile-detail-empty">点击海缆、算力中心、BGP 事件或卫星后在这里查看详情。</div>
+                </div>
+              </div>
+            </div>
+          </section>
+        </div>
+      </div>
+    </div>
    <div id="search-modal" class="earth-search-modal" aria-hidden="true">
      <div id="search-backdrop" class="earth-search-backdrop"></div>
      <div class="earth-search-sheet hud-panel" role="dialog" aria-modal="true" aria-label="搜索">
@@ -435,7 +732,7 @@
              inputmode="search"
              autocomplete="off"
              spellcheck="false"
-              placeholder="搜索海缆、登陆点、卫星、BGP 事件..."
+              placeholder="搜索海缆、登陆点、卫星、算力中心、BGP 事件..."
            >
            <button id="earth-search-clear" class="earth-search-clear hud-panel__action" type="button" aria-label="清除搜索" hidden>
              <span class="material-symbols-rounded">close</span>
@@ -443,7 +740,7 @@
          </div>
          <div id="earth-search-meta" class="earth-search-meta">输入关键词以搜索当前地球对象</div>
          <div id="earth-search-results" class="earth-search-results" role="listbox" aria-label="搜索结果"></div>
-          <div id="earth-search-empty" class="earth-search-empty">支持搜索海缆、登陆点、卫星、BGP 事件与观测站。</div>
+          <div id="earth-search-empty" class="earth-search-empty">支持搜索海缆、登陆点、卫星、算力中心、BGP 事件与观测站。</div>
        </div>
      </div>
    </div>
--- a/frontend/public/earth/js/bgp-cruise-adapter.js
+++ b/frontend/public/earth/js/bgp-cruise-adapter.js
@@ -1,17 +1,73 @@
 import * as THREE from "three";

-import { CRUISE_CONFIG, PATHS } from "./constants.js";
-import { createElbowConnectorPoints } from "./callout-connector.js";
+import { CONNECTOR_CONFIG, CRUISE_CONFIG, PATHS } from "./constants.js";
+import {
+  computeNearestPerimeterAnchor,
+  createConnectorPath,
+  resolveConnectorAnchor,
+} from "./callout-connector.js";

 const scratchBGPWorldPosition = new THREE.Vector3();
 const CRUISE_CARD_ESTIMATED_HEIGHT_PX = 420;
 const CRUISE_CARD_ESTIMATED_WIDTH_PX = 300;
 const CRUISE_CARD_VIEWPORT_PADDING_PX = 32;
 const CRUISE_CARD_SCREEN_MARGIN_PX = 12;
-const CRUISE_CARD_ANCHOR_OFFSET_PX = 18;
+const CRUISE_MOBILE_POPUP_ESTIMATED_WIDTH_PX = 220;
+const CRUISE_MOBILE_POPUP_ESTIMATED_HEIGHT_PX = 68;
+const CRUISE_MOBILE_POPUP_TOP_RATIO = 0.17;
+const CRUISE_MOBILE_POPUP_MARGIN_PX = 14;
+const CRUISE_MOBILE_DRAWER_CLEARANCE_PX = 52;
+const CRUISE_MOBILE_SLOT_OVERFLOW_WEIGHT = 3;
 const CRUISE_CONNECTOR_READY_TIMEOUT_MS = 1200;
 const CRUISE_CONNECTOR_DRAW_MS = 420;
 const CRUISE_PRESENTATION_HIDE_MS = 220;
+const MOBILE_POPUP_OBSTACLE_PADDING_PX = 16;
+const DESKTOP_PANEL_OBSTACLE_PADDING_PX = 12;
+const CRUISE_MARKER_SCREEN_PADDING_PX = 4;
+
+function getDockAxisOffsets(dockSide, gapPx) {
+  return {
+    offsetX:
+      dockSide === "right" ? gapPx : dockSide === "left" ? -gapPx : 0,
+    offsetY:
+      dockSide === "bottom" ? gapPx : dockSide === "top" ? -gapPx : 0,
+  };
+}
+
+function getObstaclePaddingBySide(side, paddingPx) {
+  if (side === "left") {
+    return { left: 0, top: paddingPx, right: paddingPx, bottom: paddingPx };
+  }
+  if (side === "right") {
+    return { left: paddingPx, top: paddingPx, right: 0, bottom: paddingPx };
+  }
+  if (side === "top") {
+    return { left: paddingPx, top: 0, right: paddingPx, bottom: paddingPx };
+  }
+  return { left: paddingPx, top: paddingPx, right: paddingPx, bottom: 0 };
+}
+
+const scratchMarkerWorldScale = new THREE.Vector3();
+const scratchCameraQuaternion = new THREE.Quaternion();
+const scratchCameraRight = new THREE.Vector3();
+const scratchCameraUp = new THREE.Vector3();
+const scratchMarkerRightPoint = new THREE.Vector3();
+const scratchMarkerLeftPoint = new THREE.Vector3();
+const scratchMarkerTopPoint = new THREE.Vector3();
+const scratchMarkerBottomPoint = new THREE.Vector3();
+
+function projectWorldToScreen(point, camera) {
+  if (!point || !camera) return null;
+  const projected = point.clone().project(camera);
+  if (!Number.isFinite(projected.x) || !Number.isFinite(projected.y)) {
+    return null;
+  }
+
+  return {
+    x: ((projected.x + 1) * 0.5) * window.innerWidth,
+    y: ((1 - projected.y) * 0.5) * window.innerHeight,
+  };
+}

 function getMarkerTimestamp(marker) {
  const rawValue = marker?.userData?.created_at_raw;
@@ -53,14 +109,78 @@ export function createBGPCruiseAdapter({
    if (!marker || !camera) return null;
    scratchBGPWorldPosition.copy(marker.position);
    marker.parent?.localToWorld(scratchBGPWorldPosition);
-    const projected = scratchBGPWorldPosition.clone().project(camera);
-    if (!Number.isFinite(projected.x) || !Number.isFinite(projected.y)) {
+    return projectWorldToScreen(scratchBGPWorldPosition, camera);
+  }
+
+  function getVisibleMobilePopup() {
+    const mobilePopup = document.getElementById("earth-mobile-popup");
+    return mobilePopup instanceof HTMLElement && !mobilePopup.hasAttribute("hidden")
+      ? mobilePopup
+      : null;
+  }
+
+  function getVisibleInfoPanel() {
+    const infoPanel = document.getElementById("info-panel");
+    return infoPanel instanceof HTMLElement && !infoPanel.hasAttribute("hidden")
+      ? infoPanel
+      : null;
+  }
+
+  function getMarkerScreenRect(marker) {
+    const center = getMarkerScreenCoords(marker);
+    if (!center || !camera || !marker) return null;
+
+    marker.getWorldScale(scratchMarkerWorldScale);
+    const worldWidth = Math.max(
+      0.0001,
+      Number(marker.userData?.baseScale ?? scratchMarkerWorldScale.x ?? 0) || scratchMarkerWorldScale.x,
+    );
+    const worldHeight = Math.max(
+      0.0001,
+      Number(scratchMarkerWorldScale.y || worldWidth),
+    );
+
+    camera.getWorldQuaternion(scratchCameraQuaternion);
+    scratchCameraRight.set(1, 0, 0).applyQuaternion(scratchCameraQuaternion).normalize();
+    scratchCameraUp.set(0, 1, 0).applyQuaternion(scratchCameraQuaternion).normalize();
+
+    scratchMarkerRightPoint
+      .copy(scratchBGPWorldPosition)
+      .addScaledVector(scratchCameraRight, worldWidth * 0.5);
+    scratchMarkerLeftPoint
+      .copy(scratchBGPWorldPosition)
+      .addScaledVector(scratchCameraRight, -worldWidth * 0.5);
+    scratchMarkerTopPoint
+      .copy(scratchBGPWorldPosition)
+      .addScaledVector(scratchCameraUp, worldHeight * 0.5);
+    scratchMarkerBottomPoint
+      .copy(scratchBGPWorldPosition)
+      .addScaledVector(scratchCameraUp, -worldHeight * 0.5);
+
+    const rightPoint = projectWorldToScreen(scratchMarkerRightPoint, camera);
+    const leftPoint = projectWorldToScreen(scratchMarkerLeftPoint, camera);
+    const topPoint = projectWorldToScreen(scratchMarkerTopPoint, camera);
+    const bottomPoint = projectWorldToScreen(scratchMarkerBottomPoint, camera);
+    if (!rightPoint || !leftPoint || !topPoint || !bottomPoint) {
      return null;
    }

+    const halfWidth = Math.max(
+      Math.abs(rightPoint.x - center.x),
+      Math.abs(leftPoint.x - center.x),
+      1,
+    );
+    const halfHeight = Math.max(
+      Math.abs(topPoint.y - center.y),
+      Math.abs(bottomPoint.y - center.y),
+      1,
+    );
+
    return {
-      x: ((projected.x + 1) * 0.5) * window.innerWidth,
-      y: ((1 - projected.y) * 0.5) * window.innerHeight,
+      x: center.x - halfWidth - CRUISE_MARKER_SCREEN_PADDING_PX,
+      y: center.y - halfHeight - CRUISE_MARKER_SCREEN_PADDING_PX,
+      width: halfWidth * 2 + CRUISE_MARKER_SCREEN_PADDING_PX * 2,
+      height: halfHeight * 2 + CRUISE_MARKER_SCREEN_PADDING_PX * 2,
    };
  }

@@ -68,6 +188,53 @@ export function createBGPCruiseAdapter({
    const markerCoords = getMarkerScreenCoords(marker);
    if (!markerCoords) return null;

+    if (document.body.classList.contains("layout-mode-mobile")) {
+      const safeBottom =
+        parseFloat(
+          getComputedStyle(document.documentElement).getPropertyValue("--safe-bottom"),
+        ) || 0;
+      const estimatedCardWidth = Math.min(
+        CRUISE_MOBILE_POPUP_ESTIMATED_WIDTH_PX,
+        window.innerWidth - CRUISE_MOBILE_POPUP_MARGIN_PX * 2,
+      );
+      const estimatedCardHeight = CRUISE_MOBILE_POPUP_ESTIMATED_HEIGHT_PX;
+      const topBound = Math.max(
+        CRUISE_MOBILE_POPUP_MARGIN_PX,
+        Math.min(
+          window.innerHeight * CRUISE_MOBILE_POPUP_TOP_RATIO,
+          window.innerHeight -
+            CRUISE_MOBILE_DRAWER_CLEARANCE_PX -
+            safeBottom -
+            estimatedCardHeight -
+            CRUISE_MOBILE_POPUP_MARGIN_PX,
+        ),
+      );
+      const rightSlotLeft = Math.max(
+        CRUISE_MOBILE_POPUP_MARGIN_PX,
+        window.innerWidth - estimatedCardWidth - CRUISE_MOBILE_POPUP_MARGIN_PX,
+      );
+      const leftSlotLeft = CRUISE_MOBILE_POPUP_MARGIN_PX;
+      const rightSlotCenterX = rightSlotLeft + estimatedCardWidth * 0.5;
+      const leftSlotCenterX = leftSlotLeft + estimatedCardWidth * 0.5;
+      const rightClearance = rightSlotLeft - markerCoords.x;
+      const leftClearance = markerCoords.x - (leftSlotLeft + estimatedCardWidth);
+      const rightCost =
+        Math.max(0, -rightClearance) * CRUISE_MOBILE_SLOT_OVERFLOW_WEIGHT +
+        Math.abs(rightSlotCenterX - markerCoords.x);
+      const leftCost =
+        Math.max(0, -leftClearance) * CRUISE_MOBILE_SLOT_OVERFLOW_WEIGHT +
+        Math.abs(markerCoords.x - leftSlotCenterX);
+      const placeOnRight = rightCost <= leftCost;
+      const left = placeOnRight ? rightSlotLeft : leftSlotLeft;
+      return {
+        x: left,
+        y: topBound,
+        width: estimatedCardWidth,
+        height: estimatedCardHeight,
+        dockSide: placeOnRight ? "left" : "right",
+      };
+    }
+
    const hudScale =
      Number.parseFloat(
        getComputedStyle(document.documentElement).getPropertyValue("--hud-scale"),
@@ -94,38 +261,148 @@ export function createBGPCruiseAdapter({
      Math.max(margin, y),
      Math.max(margin, window.innerHeight - estimatedCardHeight - margin),
    );
-    const anchorY = clampedY + Math.max(
-      CRUISE_CARD_ANCHOR_OFFSET_PX * hudScale,
-      estimatedCardHeight * 0.18,
-    );
-
    return {
      x: clampedX,
      y: clampedY,
      width: estimatedCardWidth,
      height: estimatedCardHeight,
-      anchorX: clampedX - CRUISE_CONFIG.linkPanelGapPx,
-      anchorY,
    };
  }

+  function getCardAnchorTarget() {
+    const mobilePopup = getVisibleMobilePopup();
+    if (
+      document.body.classList.contains("layout-mode-mobile") &&
+      mobilePopup
+    ) {
+      const dockSide = mobilePopup.dataset.dockSide || "left";
+      const { offsetX, offsetY } = getDockAxisOffsets(
+        dockSide,
+        CONNECTOR_CONFIG.panelGapPx,
+      );
+      return {
+        element: mobilePopup,
+        side: dockSide,
+        alignRatio: 0.5,
+        offsetX,
+        offsetY,
+      };
+    }
+
+    return null;
+  }
+
+  function getCardObstacleTarget(fallbackPlacement = null) {
+    const mobilePopup = getVisibleMobilePopup();
+    if (
+      document.body.classList.contains("layout-mode-mobile") &&
+      mobilePopup
+    ) {
+      const side = mobilePopup.dataset.dockSide || "left";
+      return {
+        element: mobilePopup,
+        padding: getObstaclePaddingBySide(side, MOBILE_POPUP_OBSTACLE_PADDING_PX),
+      };
+    }
+
+    const infoPanel = getVisibleInfoPanel();
+    if (infoPanel) {
+      return {
+        element: infoPanel,
+        padding: getObstaclePaddingBySide("left", DESKTOP_PANEL_OBSTACLE_PADDING_PX),
+      };
+    }
+
+    if (fallbackPlacement) {
+      return {
+        x: fallbackPlacement.x,
+        y: fallbackPlacement.y,
+        width: fallbackPlacement.width ?? 0,
+        height: fallbackPlacement.height ?? 0,
+        padding: DESKTOP_PANEL_OBSTACLE_PADDING_PX,
+      };
+    }
+
+    return null;
+  }
+
+  function resolveAdaptiveDockSide(markerCoords, fallbackPlacement = null) {
+    const mobilePopup = getVisibleMobilePopup();
+    const popupRect =
+      mobilePopup
+        ? mobilePopup.getBoundingClientRect()
+        : fallbackPlacement
+          ? {
+              left: fallbackPlacement.x,
+              top: fallbackPlacement.y,
+              right: fallbackPlacement.x + (fallbackPlacement.width ?? 0),
+              bottom: fallbackPlacement.y + (fallbackPlacement.height ?? 0),
+            }
+          : null;
+    if (!markerCoords || !popupRect) return fallbackPlacement?.dockSide === "right" ? "right" : "left";
+
+    return computeNearestPerimeterAnchor(markerCoords, popupRect, 0)?.side || "left";
+  }
+
+  function syncMobileDockSide(markerCoords, fallbackPlacement = null) {
+    const mobilePopup = getVisibleMobilePopup();
+    const dockSide = resolveAdaptiveDockSide(markerCoords, fallbackPlacement);
+    if (mobilePopup) {
+      mobilePopup.dataset.dockSide = dockSide;
+    }
+  }
+
  function getConnectorPath(marker) {
    const markerCoords = getMarkerScreenCoords(marker);
-    const targetCardCoords = cardPlacement || getCardScreenCoords(marker);
-    if (!markerCoords || !targetCardCoords) return null;
+    const markerRect = getMarkerScreenRect(marker);
+    if (!markerCoords) return null;

-    return createElbowConnectorPoints(
-      markerCoords,
-      {
-        x: targetCardCoords.anchorX,
-        y: targetCardCoords.anchorY,
-      },
-      {
+    if (document.body.classList.contains("layout-mode-mobile")) {
+      const targetCardCoords = cardPlacement || getCardScreenCoords(marker);
+      syncMobileDockSide(markerCoords, targetCardCoords);
+      const cardAnchorTarget = getCardAnchorTarget();
+      const cardAnchorCoords = resolveConnectorAnchor(cardAnchorTarget);
+      const cardObstacleTarget = getCardObstacleTarget(targetCardCoords);
+      if (!cardAnchorCoords) return null;
+
+      return createConnectorPath(markerCoords, cardAnchorTarget ?? cardAnchorCoords, {
+        routingMode: "adaptive",
+        sourceRect: markerRect,
+        targetAnchor: cardAnchorTarget ?? cardAnchorCoords,
+        obstacles: cardObstacleTarget ? [cardObstacleTarget] : [],
        startFrom: "source",
-        sourceGapPx: CRUISE_CONFIG.linkMarkerGapPx,
-        targetGapPx: CRUISE_CONFIG.linkPanelGapPx,
-        elbowOffsetPx: CRUISE_CONFIG.linkElbowOffsetPx,
-        elbowDropPx: CRUISE_CONFIG.linkElbowDropPx,
+        sourceGapPx: CONNECTOR_CONFIG.markerGapPx,
+        targetGapPx: CONNECTOR_CONFIG.panelGapPx,
+        obstacleClearancePx: CONNECTOR_CONFIG.obstacleClearancePx,
+      });
+    }
+
+    const targetCardCoords = cardPlacement || getCardScreenCoords(marker);
+    const cardObstacleTarget = getCardObstacleTarget(targetCardCoords);
+    if (!targetCardCoords) return null;
+
+    const infoPanel = getVisibleInfoPanel();
+    const desktopTarget =
+      infoPanel
+        ? infoPanel
+        : {
+            x: targetCardCoords.x,
+            y: targetCardCoords.y,
+            width: targetCardCoords.width,
+            height: targetCardCoords.height,
+          };
+
+    return createConnectorPath(
+      markerCoords,
+      desktopTarget,
+      {
+        routingMode: "adaptive",
+        sourceRect: markerRect,
+        obstacles: cardObstacleTarget ? [cardObstacleTarget] : [],
+        obstacleClearancePx: CONNECTOR_CONFIG.obstacleClearancePx,
+        startFrom: "source",
+        sourceGapPx: CONNECTOR_CONFIG.markerGapPx,
+        targetGapPx: CONNECTOR_CONFIG.panelGapPx,
      },
    );
  }
@@ -166,7 +443,6 @@ export function createBGPCruiseAdapter({
    async focusMarker(marker, { interrupt = false } = {}) {
      if (!marker) return;
      currentMarkerId = marker.userData?.id || null;
-      cardPlacement = getCardScreenCoords(marker);
      setMarkerLocked(marker);
      showMarkerOverlay(marker);

@@ -179,10 +455,31 @@ export function createBGPCruiseAdapter({
          : CRUISE_CONFIG.focusDurationMs,
        suppressStatus: true,
      });
+
+      cardPlacement = getCardScreenCoords(marker);
    },
    async presentMarker(marker, { context }) {
      if (!marker) return false;

+      const showCruiseMarkerInfo = ({ reveal = true } = {}) =>
+        showMarkerInfo(marker, {
+          x: cardPlacement?.x,
+          y: cardPlacement?.y,
+          absolute: true,
+          reveal,
+          anchorStable: true,
+          dockSide: cardPlacement?.dockSide,
+        });
+
+      showCruiseMarkerInfo({ reveal: false });
+      await context.nextFrame();
+      if (!context.isCurrent()) {
+        cardPlacement = null;
+        connector.hide();
+        hideInfo();
+        return false;
+      }
+
      const startedAt = performance.now();
      let connectorReady = false;
      while (context.isCurrent()) {
@@ -211,18 +508,10 @@ export function createBGPCruiseAdapter({
        return false;
      }

-      showMarkerInfo(marker, {
-        x: cardPlacement?.x,
-        y: cardPlacement?.y,
-        absolute: true,
-      });
+      showCruiseMarkerInfo();
      await context.nextFrame();
      if (!isInfoVisible()) {
-        showMarkerInfo(marker, {
-          x: cardPlacement?.x,
-          y: cardPlacement?.y,
-          absolute: true,
-        });
+        showCruiseMarkerInfo();
        await context.nextFrame();
      }

--- a/frontend/public/earth/js/bgp.js
+++ b/frontend/public/earth/js/bgp.js
@@ -1,7 +1,7 @@
 import * as THREE from "three";

 import { BGP_CONFIG, CONFIG, PATHS } from "./constants.js";
-import { latLonToVector3 } from "./utils.js";
+import { getSurfaceMarkerCameraScale, latLonToVector3 } from "./utils.js";

 const bgpGroup = new THREE.Group();
 const bgpOverlayGroup = new THREE.Group();
@@ -280,37 +280,23 @@ function blendHexColors(fromHex, toHex, ratio) {
 function getCollectorDistanceScale(marker, camera) {
  if (!marker || !camera || BGP_CONFIG.sizeStabilization?.enabled === false) return 1;

-  marker.getWorldPosition(collectorWorldPosition);
-  const distanceToCamera = camera.position.distanceTo(collectorWorldPosition);
-  const referenceDistance = CONFIG.defaultCameraZ - CONFIG.earthRadius + BGP_CONFIG.collectorAltitudeOffset;
-  const referenceFovRad = (75 * Math.PI) / 180;
-  const cameraFovRad = ((camera.fov || 75) * Math.PI) / 180;
-  const min = Number(BGP_CONFIG.sizeStabilization?.collectorMin ?? 0.6);
-  const max = Number(BGP_CONFIG.sizeStabilization?.collectorMax ?? 1.9);
-  const worldPerPixel =
-    distanceToCamera * Math.tan(cameraFovRad / 2);
-  const referenceWorldPerPixel =
-    referenceDistance * Math.tan(referenceFovRad / 2);
-
-  return clamp(worldPerPixel / referenceWorldPerPixel, min, max);
+  return getSurfaceMarkerCameraScale(camera, {
+    altitudeOffset: BGP_CONFIG.collectorAltitudeOffset,
+    referenceFov: 75,
+    min: Number(BGP_CONFIG.sizeStabilization?.collectorMin ?? 0.6),
+    max: Number(BGP_CONFIG.sizeStabilization?.collectorMax ?? 1.9),
+  });
 }

 function getEventDistanceScale(marker, camera) {
  if (!marker || !camera || BGP_CONFIG.sizeStabilization?.enabled === false) return 1;

-  marker.getWorldPosition(collectorWorldPosition);
-  const distanceToCamera = camera.position.distanceTo(collectorWorldPosition);
-  const referenceDistance = CONFIG.defaultCameraZ - CONFIG.earthRadius + BGP_CONFIG.altitudeOffset;
-  const referenceFovRad = (75 * Math.PI) / 180;
-  const cameraFovRad = ((camera.fov || 75) * Math.PI) / 180;
-  const min = Number(BGP_CONFIG.sizeStabilization?.eventMin ?? 0.7);
-  const max = Number(BGP_CONFIG.sizeStabilization?.eventMax ?? 1.9);
-  const worldPerPixel =
-    distanceToCamera * Math.tan(cameraFovRad / 2);
-  const referenceWorldPerPixel =
-    referenceDistance * Math.tan(referenceFovRad / 2);
-
-  return clamp(worldPerPixel / referenceWorldPerPixel, min, max);
+  return getSurfaceMarkerCameraScale(camera, {
+    altitudeOffset: BGP_CONFIG.altitudeOffset,
+    referenceFov: 75,
+    min: Number(BGP_CONFIG.sizeStabilization?.eventMin ?? 0.7),
+    max: Number(BGP_CONFIG.sizeStabilization?.eventMax ?? 1.9),
+  });
 }

 function orientCollectorMarkerToSurface(marker, position) {
--- a/frontend/public/earth/js/cables.js
+++ b/frontend/public/earth/js/cables.js
@@ -9,8 +9,8 @@ import {
  CABLE_STATE,
  CABLE_CONFIG,
 } from "./constants.js";
-import { latLonToVector3 } from "./utils.js";
-import { updateEarthStats, showStatusMessage } from "./ui.js";
+import { getSurfaceMarkerCameraScale, latLonToVector3 } from "./utils.js";
+import { setEarthStatValue, updateEarthStats, showStatusMessage } from "./ui.js";
 import { showInfoCard } from "./info-card.js";
 import { setLegendItems, setLegendMode } from "./legend.js";

@@ -21,7 +21,6 @@ let cableIdMap = new Map();
 let cableStates = new Map();
 let cablesVisible = true;
 let landingPointGeometry = null;
-const landingPointWorldPosition = new THREE.Vector3();

 function clamp(value, min, max) {
  return Math.min(max, Math.max(min, value));
@@ -33,24 +32,13 @@ function getLandingPointDistanceScale(point, camera) {
    !camera ||
    CABLE_CONFIG.landingPointSizeStabilization?.enabled === false
  ) return 1;
-  point.getWorldPosition(landingPointWorldPosition);
-  const distanceToCamera = camera.position.distanceTo(landingPointWorldPosition);
-  const referenceDistance =
-    CONFIG.defaultCameraZ -
-    CONFIG.earthRadius +
-    CABLE_CONFIG.landingPoint.altitudeOffset;
-  const referenceFovDeg =
-    CABLE_CONFIG.landingPointSizeStabilization?.referenceFov || 75;
-  const referenceFovRad = (referenceFovDeg * Math.PI) / 180;
-  const cameraFovRad =
-    (((camera.fov || referenceFovDeg)) * Math.PI) / 180;
-  const worldPerPixel = distanceToCamera * Math.tan(cameraFovRad / 2);
-  const referenceWorldPerPixel = referenceDistance * Math.tan(referenceFovRad / 2);
-  return clamp(
-    worldPerPixel / referenceWorldPerPixel,
-    CABLE_CONFIG.landingPointSizeStabilization?.min ?? 0.12,
-    CABLE_CONFIG.landingPointSizeStabilization?.max ?? 3.0,
-  );
+
+  return getSurfaceMarkerCameraScale(camera, {
+    altitudeOffset: CABLE_CONFIG.landingPoint.altitudeOffset,
+    referenceFov: CABLE_CONFIG.landingPointSizeStabilization?.referenceFov || 75,
+    min: CABLE_CONFIG.landingPointSizeStabilization?.min ?? 0.12,
+    max: CABLE_CONFIG.landingPointSizeStabilization?.max ?? 3.0,
+  });
 }

 function disposeMaterial(material) {
@@ -336,9 +324,8 @@ export async function loadGeoJSONFromPath(scene, earthObj, options = {}) {
        feature.properties.status === "In Service"),
  ).length;

-  const cableCountEl = document.getElementById("cable-count");
  const statusEl = document.getElementById("cable-status-summary");
-  if (cableCountEl) cableCountEl.textContent = cableCount + "个";
+  setEarthStatValue("cable-count", `${cableCount}个`);
  if (statusEl) statusEl.textContent = `${inServiceCount}/${cableCount} 运行中`;

  updateEarthStats({
@@ -435,10 +422,7 @@ export async function loadLandingPoints(scene, earthObj, options = {}) {
    validCount++;
  }

-  const landingPointCountEl = document.getElementById("landing-point-count");
-  if (landingPointCountEl) {
-    landingPointCountEl.textContent = validCount + "个";
-  }
+  setEarthStatValue("landing-point-count", `${validCount}个`);

  if (!silent) {
    showStatusMessage(`成功加载 ${validCount} 个登陆点`, "success");
--- a/frontend/public/earth/js/callout-connector.js
+++ b/frontend/public/earth/js/callout-connector.js
@@ -1,13 +1,316 @@
 const SVG_NS = "http://www.w3.org/2000/svg";
-const DEFAULT_CLASS_NAME = "info-card-cruise-link";
-const DEFAULT_DRAW_ANIMATION_NAME = "cruiseConnectorDraw";
+const DEFAULT_CLASS_NAME = "callout-connector";
+const DEFAULT_DRAW_ANIMATION_NAME = "calloutConnectorDraw";
+const DEFAULT_SOURCE_ANCHOR_GAP_PX = 6;
+const MIN_SOURCE_ANCHOR_GAP_PX = 4;

 function createSvgElement(tagName) {
  return document.createElementNS(SVG_NS, tagName);
 }

+function resolveElementAnchorSide(side) {
+  switch (side) {
+    case "right":
+    case "top":
+    case "bottom":
+    case "left":
+      return side;
+    default:
+      return "left";
+  }
+}
+
+function resolveElementAnchorAlignRatio(ratio) {
+  if (!Number.isFinite(ratio)) return 0.5;
+  return Math.min(Math.max(ratio, 0), 1);
+}
+
+function resolveAnchorElement(target) {
+  if (target instanceof HTMLElement) return target;
+  if (target?.element instanceof HTMLElement) return target.element;
+  if (typeof target?.selector === "string") {
+    const matched = document.querySelector(target.selector);
+    return matched instanceof HTMLElement ? matched : null;
+  }
+  return null;
+}
+
+function resolveRectElement(target) {
+  if (target instanceof HTMLElement) return target;
+  if (target?.element instanceof HTMLElement) return target.element;
+  if (typeof target?.selector === "string") {
+    const matched = document.querySelector(target.selector);
+    return matched instanceof HTMLElement ? matched : null;
+  }
+  return null;
+}
+
+function isFiniteRect(rect) {
+  return (
+    rect &&
+    Number.isFinite(rect.left) &&
+    Number.isFinite(rect.top) &&
+    Number.isFinite(rect.right) &&
+    Number.isFinite(rect.bottom)
+  );
+}
+
+function normalizeRect(rect) {
+  if (!rect) return null;
+  const left = Number(rect.left);
+  const top = Number(rect.top);
+  const right = Number(rect.right);
+  const bottom = Number(rect.bottom);
+  if (
+    !Number.isFinite(left) ||
+    !Number.isFinite(top) ||
+    !Number.isFinite(right) ||
+    !Number.isFinite(bottom)
+  ) {
+    return null;
+  }
+  return {
+    left: Math.min(left, right),
+    top: Math.min(top, bottom),
+    right: Math.max(left, right),
+    bottom: Math.max(top, bottom),
+  };
+}
+
+function expandRect(rect, padding = 0) {
+  const normalized = normalizeRect(rect);
+  if (!normalized) return null;
+  if (typeof padding === "object" && padding !== null) {
+    const leftPadding = Number.isFinite(padding.left) ? Number(padding.left) : 0;
+    const topPadding = Number.isFinite(padding.top) ? Number(padding.top) : 0;
+    const rightPadding = Number.isFinite(padding.right) ? Number(padding.right) : 0;
+    const bottomPadding = Number.isFinite(padding.bottom) ? Number(padding.bottom) : 0;
+    return {
+      left: normalized.left - leftPadding,
+      top: normalized.top - topPadding,
+      right: normalized.right + rightPadding,
+      bottom: normalized.bottom + bottomPadding,
+    };
+  }
+  return {
+    left: normalized.left - padding,
+    top: normalized.top - padding,
+    right: normalized.right + padding,
+    bottom: normalized.bottom + padding,
+  };
+}
+
+function dedupeSequentialPoints(points) {
+  const nextPoints = [];
+  for (const point of points) {
+    const previous = nextPoints[nextPoints.length - 1];
+    if (
+      previous &&
+      Math.abs(previous.x - point.x) < 0.5 &&
+      Math.abs(previous.y - point.y) < 0.5
+    ) {
+      continue;
+    }
+    nextPoints.push(point);
+  }
+  return nextPoints;
+}
+
+// Compute the anchor point on the nearest perimeter edge of rect to source.
+// gap is applied outward from the edge, so the anchor is outside the rect.
+export function computeNearestPerimeterAnchor(source, rect, gap = 0) {
+  const { left, top, right, bottom } = rect;
+  const midX = (left + right) * 0.5;
+  const midY = (top + bottom) * 0.5;
+
+  if (source.x <= left) return { x: left - gap, y: midY, side: "left" };
+  if (source.x >= right) return { x: right + gap, y: midY, side: "right" };
+  if (source.y <= top) return { x: midX, y: top - gap, side: "top" };
+  if (source.y >= bottom) return { x: midX, y: bottom + gap, side: "bottom" };
+
+  // Source inside rect: snap to nearest edge midpoint
+  const dLeft = source.x - left;
+  const dRight = right - source.x;
+  const dTop = source.y - top;
+  const dBottom = bottom - source.y;
+  const minD = Math.min(dLeft, dRight, dTop, dBottom);
+
+  if (minD === dLeft) return { x: left - gap, y: midY, side: "left" };
+  if (minD === dRight) return { x: right + gap, y: midY, side: "right" };
+  if (minD === dTop) return { x: midX, y: top - gap, side: "top" };
+  return { x: midX, y: bottom + gap, side: "bottom" };
+}
+
+export function resolveConnectorObstacleRect(target, options = {}) {
+  if (!target) return null;
+
+  if (typeof target === "function") {
+    return resolveConnectorObstacleRect(target(), options);
+  }
+
+  const resolvedPadding =
+    target && (Number.isFinite(target.padding) || (typeof target.padding === "object" && target.padding))
+      ? target.padding
+      : options.padding;
+  const padding =
+    Number.isFinite(resolvedPadding) || (typeof resolvedPadding === "object" && resolvedPadding)
+      ? resolvedPadding
+      : 0;
+
+  if (isFiniteRect(target)) {
+    return expandRect(target, padding);
+  }
+
+  if (
+    Number.isFinite(target.x) &&
+    Number.isFinite(target.y) &&
+    Number.isFinite(target.width) &&
+    Number.isFinite(target.height)
+  ) {
+    return expandRect(
+      {
+        left: Number(target.x),
+        top: Number(target.y),
+        right: Number(target.x) + Number(target.width),
+        bottom: Number(target.y) + Number(target.height),
+      },
+      padding,
+    );
+  }
+
+  const element = resolveRectElement(target);
+  if (!(element instanceof HTMLElement)) return null;
+  return expandRect(element.getBoundingClientRect(), padding);
+}
+
+export function resolveConnectorAnchor(target) {
+  if (!target) return null;
+
+  if (typeof target === "function") {
+    return resolveConnectorAnchor(target());
+  }
+
+  if (Number.isFinite(target.x) && Number.isFinite(target.y)) {
+    return { x: Number(target.x), y: Number(target.y) };
+  }
+
+  const element = resolveAnchorElement(target);
+  if (!(element instanceof HTMLElement)) return null;
+
+  const rect = element.getBoundingClientRect();
+  const side = resolveElementAnchorSide(target.side);
+  const alignRatio = resolveElementAnchorAlignRatio(
+    target.alignRatio ?? target.anchorRatio ?? target.ratio,
+  );
+  const offsetX = Number.isFinite(target.offsetX) ? Number(target.offsetX) : 0;
+  const offsetY = Number.isFinite(target.offsetY) ? Number(target.offsetY) : 0;
+
+  let x = rect.left + rect.width * 0.5;
+  let y = rect.top + rect.height * 0.5;
+
+  if (side === "left") {
+    x = rect.left;
+    y = rect.top + rect.height * alignRatio;
+  } else if (side === "right") {
+    x = rect.right;
+    y = rect.top + rect.height * alignRatio;
+  } else if (side === "top") {
+    x = rect.left + rect.width * alignRatio;
+    y = rect.top;
+  } else if (side === "bottom") {
+    x = rect.left + rect.width * alignRatio;
+    y = rect.bottom;
+  }
+
+  return {
+    x: x + offsetX,
+    y: y + offsetY,
+  };
+}
+
+function resolveConnectorRect(target) {
+  return resolveConnectorObstacleRect(target, { padding: 0 });
+}
+
+function createRectSideMidpoint(rect, side, gap = 0) {
+  const normalizedRect = normalizeRect(rect);
+  if (!normalizedRect) return null;
+
+  const midpointX = (normalizedRect.left + normalizedRect.right) * 0.5;
+  const midpointY = (normalizedRect.top + normalizedRect.bottom) * 0.5;
+
+  if (side === "left") {
+    return { x: normalizedRect.left - gap, y: midpointY, side };
+  }
+  if (side === "right") {
+    return { x: normalizedRect.right + gap, y: midpointY, side };
+  }
+  if (side === "top") {
+    return { x: midpointX, y: normalizedRect.top - gap, side };
+  }
+  if (side === "bottom") {
+    return { x: midpointX, y: normalizedRect.bottom + gap, side };
+  }
+  return null;
+}
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function createRectEdgeAnchor(rect, side, position, gap = 0) {
+  const normalizedRect = normalizeRect(rect);
+  if (!normalizedRect) return null;
+
+  const x =
+    side === "left"
+      ? normalizedRect.left - gap
+      : side === "right"
+        ? normalizedRect.right + gap
+        : clamp(
+            Number.isFinite(position?.x) ? Number(position.x) : (normalizedRect.left + normalizedRect.right) * 0.5,
+            normalizedRect.left,
+            normalizedRect.right,
+          );
+  const y =
+    side === "top"
+      ? normalizedRect.top - gap
+      : side === "bottom"
+        ? normalizedRect.bottom + gap
+        : clamp(
+            Number.isFinite(position?.y) ? Number(position.y) : (normalizedRect.top + normalizedRect.bottom) * 0.5,
+            normalizedRect.top,
+            normalizedRect.bottom,
+          );
+
+  return { x, y, side };
+}
+
+function createOrthogonalPointsFromDirections(startPoint, endPoint, directions = []) {
+  if (!startPoint || !endPoint) return null;
+  const normalizedDirections = directions.filter(Boolean);
+  if (!normalizedDirections.length) {
+    return dedupeSequentialPoints([startPoint, endPoint]);
+  }
+
+  const firstDirection = normalizedDirections[0];
+  const corner =
+    firstDirection === "left" || firstDirection === "right"
+      ? { x: endPoint.x, y: startPoint.y }
+      : { x: startPoint.x, y: endPoint.y };
+
+  return dedupeSequentialPoints([startPoint, corner, endPoint]);
+}
+
+function resolveSourceAnchorGapPx(sourceGapPx) {
+  if (!Number.isFinite(sourceGapPx)) return DEFAULT_SOURCE_ANCHOR_GAP_PX;
+  return Math.max(MIN_SOURCE_ANCHOR_GAP_PX, Math.round(sourceGapPx * 0.4));
+}
+
 export function createElbowConnectorPoints(source, target, options = {}) {
-  if (!source || !target) return null;
+  const resolvedSource = resolveConnectorAnchor(source);
+  const resolvedTarget = resolveConnectorAnchor(target);
+  if (!resolvedSource || !resolvedTarget) return null;

  const {
    startFrom = "source",
@@ -17,8 +320,8 @@ export function createElbowConnectorPoints(source, target, options = {}) {
    elbowDropPx = 14,
  } = options;

-  const sourcePoint = { x: Number(source.x), y: Number(source.y) };
-  const targetPoint = { x: Number(target.x), y: Number(target.y) };
+  const sourcePoint = { x: Number(resolvedSource.x), y: Number(resolvedSource.y) };
+  const targetPoint = { x: Number(resolvedTarget.x), y: Number(resolvedTarget.y) };
  if (
    !Number.isFinite(sourcePoint.x) ||
    !Number.isFinite(sourcePoint.y) ||
@@ -53,6 +356,163 @@ export function createElbowConnectorPoints(source, target, options = {}) {
  };
 }

+function createAdaptiveConnectorPoints(source, target, options = {}) {
+  const resolvedSource = resolveConnectorAnchor(source);
+  if (!resolvedSource) return null;
+
+  const {
+    startFrom = "source",
+    sourceGapPx = 12,
+    targetGapPx = 8,
+    obstacleClearancePx = 8,
+    obstacles = [],
+    targetAnchor = null,
+    sourceRect = null,
+  } = options;
+
+  const sp = { x: Number(resolvedSource.x), y: Number(resolvedSource.y) };
+  if (!Number.isFinite(sp.x) || !Number.isFinite(sp.y)) return null;
+
+  const normalizedObstacles = (Array.isArray(obstacles) ? obstacles : [obstacles])
+    .map((obstacle) => resolveConnectorObstacleRect(obstacle, { padding: obstacleClearancePx }))
+    .filter(Boolean);
+
+  const fallbackTargetRect = resolveConnectorObstacleRect(target, { padding: 0 });
+  const resolvedTarget =
+    resolveConnectorAnchor(targetAnchor ?? target) ||
+    (fallbackTargetRect
+      ? computeNearestPerimeterAnchor(
+          sp,
+          fallbackTargetRect,
+          Math.max(targetGapPx, obstacleClearancePx + 1),
+        )
+      : null);
+  if (!resolvedTarget) return null;
+
+  const end = { x: Number(resolvedTarget.x), y: Number(resolvedTarget.y) };
+  if (!Number.isFinite(end.x) || !Number.isFinite(end.y)) return null;
+
+  const primaryObstacle = normalizedObstacles[0] || null;
+  const relationRect = fallbackTargetRect || primaryObstacle;
+  if (!relationRect) return null;
+
+  const sourceRelationRect = resolveConnectorRect(sourceRect ?? source);
+  const targetCenterX = (relationRect.left + relationRect.right) * 0.5;
+  const targetCenterY = (relationRect.top + relationRect.bottom) * 0.5;
+
+  const leftMidpoint = createRectSideMidpoint(relationRect, "left", targetGapPx);
+  const rightMidpoint = createRectSideMidpoint(relationRect, "right", targetGapPx);
+  const isTargetAbove = relationRect.bottom < sp.y;
+  const isTargetBelow = relationRect.top > sp.y;
+  const isSourceWithinAnchorHorizontalRange =
+    sp.x >= leftMidpoint.x && sp.x <= rightMidpoint.x;
+  const isRightMidpointLeftOfSource = rightMidpoint.x < sp.x;
+  const isLeftMidpointRightOfSource = leftMidpoint.x > sp.x;
+
+  let directions = [];
+  let targetSide = null;
+  const isTargetCenterWithinSourceVerticalRange =
+    sourceRelationRect &&
+    targetCenterY >= sourceRelationRect.top &&
+    targetCenterY <= sourceRelationRect.bottom;
+  const isTargetCenterWithinSourceHorizontalRange =
+    sourceRelationRect &&
+    targetCenterX >= sourceRelationRect.left &&
+    targetCenterX <= sourceRelationRect.right;
+
+  if (isRightMidpointLeftOfSource) {
+    targetSide = "right";
+    if (isTargetCenterWithinSourceVerticalRange) {
+      directions = ["left"];
+    } else if (rightMidpoint.y < sp.y) {
+      directions = ["top", "left"];
+    } else if (rightMidpoint.y > sp.y) {
+      directions = ["bottom", "left"];
+    } else {
+      directions = ["left"];
+    }
+  } else if (isLeftMidpointRightOfSource) {
+    targetSide = "left";
+    if (isTargetCenterWithinSourceVerticalRange) {
+      directions = ["right"];
+    } else if (leftMidpoint.y < sp.y) {
+      directions = ["top", "right"];
+    } else if (leftMidpoint.y > sp.y) {
+      directions = ["bottom", "right"];
+    } else {
+      directions = ["right"];
+    }
+  } else if (isSourceWithinAnchorHorizontalRange) {
+    if (isTargetAbove) {
+      targetSide = "bottom";
+      directions = isTargetCenterWithinSourceHorizontalRange
+        ? ["top"]
+        : targetCenterX >= sp.x
+          ? ["right", "top"]
+          : ["left", "top"];
+    } else if (isTargetBelow) {
+      targetSide = "top";
+      directions = isTargetCenterWithinSourceHorizontalRange
+        ? ["bottom"]
+        : targetCenterX >= sp.x
+          ? ["right", "bottom"]
+          : ["left", "bottom"];
+    }
+  }
+
+  if (!targetSide || !directions.length) {
+    return createElbowConnectorPoints(source, targetAnchor ?? target, options);
+  }
+
+  const derivedTargetAnchor = createRectSideMidpoint(relationRect, targetSide, targetGapPx);
+  const targetPoint =
+    resolvedTarget && targetAnchor
+      ? end
+      : derivedTargetAnchor || end;
+
+  const sourceSide = directions[0] || null;
+  const sourceAnchorGapPx = resolveSourceAnchorGapPx(sourceGapPx);
+  const shouldSlideSourceAnchorAlongEdge =
+    (sourceSide === "left" || sourceSide === "right") &&
+    isTargetCenterWithinSourceVerticalRange ||
+    (sourceSide === "top" || sourceSide === "bottom") &&
+    isTargetCenterWithinSourceHorizontalRange;
+  const derivedSourceAnchor =
+    sourceRelationRect && sourceSide
+      ? shouldSlideSourceAnchorAlongEdge
+        ? createRectEdgeAnchor(sourceRelationRect, sourceSide, targetPoint, sourceAnchorGapPx)
+        : createRectSideMidpoint(sourceRelationRect, sourceSide, sourceAnchorGapPx)
+      : null;
+  const startPoint = derivedSourceAnchor || sp;
+
+  let pts = createOrthogonalPointsFromDirections(startPoint, targetPoint, directions);
+  if (!pts) {
+    return createElbowConnectorPoints(source, targetAnchor ?? target, options);
+  }
+  pts = dedupeSequentialPoints(pts);
+  return {
+    points: startFrom === "target" ? pts.slice().reverse() : pts,
+    start: startFrom === "target" ? pts[pts.length - 1] : pts[0],
+    end: startFrom === "target" ? pts[0] : pts[pts.length - 1],
+  };
+}
+
+export function createConnectorPath(source, target, options = {}) {
+  const {
+    routingMode = "simple",
+  } = options;
+
+  if (routingMode === "adaptive") {
+    return createAdaptiveConnectorPoints(source, target, options);
+  }
+
+  if (routingMode === "simple") {
+    return createElbowConnectorPoints(source, target, options);
+  }
+
+  return createElbowConnectorPoints(source, target, options);
+}
+
 export class CalloutConnector {
  constructor({
    container = null,
--- a/frontend/public/earth/js/compute-centers.js
+++ b/frontend/public/earth/js/compute-centers.js
@@ -0,0 +1,375 @@
+import * as THREE from "three";
+
+import { COMPUTE_CENTER_CONFIG, CONFIG, PATHS } from "./constants.js";
+import { getSurfaceMarkerCameraScale, latLonToVector3 } from "./utils.js";
+
+const computeCenterGroup = new THREE.Group();
+const computeCenterMarkers = [];
+const textureCache = new Map();
+let showComputeCenters = true;
+let supercomputerCount = 0;
+let gpuClusterCount = 0;
+
+function buildComputeCenterMarkerData(feature) {
+  const props = feature?.properties || {};
+  const coordinates = feature?.geometry?.coordinates || [];
+  const longitude = Number(coordinates[0]);
+  const latitude = Number(coordinates[1]);
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    return null;
+  }
+
+  return {
+    ...props,
+    latitude,
+    longitude,
+    displayLatitude: latitude,
+    displayLongitude: longitude,
+    site_type: normalizeSiteType(props.site_type),
+  };
+}
+
+function spreadComputeCenterPositions(markers) {
+  const groups = new Map();
+  const precision = COMPUTE_CENTER_CONFIG.overlapSpread.groupPrecision;
+
+  markers.forEach((marker) => {
+    const key = `${marker.latitude.toFixed(precision)}|${marker.longitude.toFixed(precision)}`;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(marker);
+  });
+
+  groups.forEach((group) => {
+    if (group.length <= 1) return;
+
+    const radius = COMPUTE_CENTER_CONFIG.overlapSpread.radius;
+    const offsetStep = COMPUTE_CENTER_CONFIG.overlapSpread.offsetStep;
+    group.forEach((marker, index) => {
+      const angle = (Math.PI * 2 * index) / group.length;
+      marker.displayLatitude =
+        marker.latitude + Math.sin(angle) * radius * offsetStep;
+      marker.displayLongitude =
+        marker.longitude + Math.cos(angle) * radius * offsetStep;
+      marker.isSpread = true;
+      marker.groupSize = group.length;
+    });
+  });
+
+  markers.forEach((marker) => {
+    if (marker.isSpread) return;
+    marker.displayLatitude = marker.latitude;
+    marker.displayLongitude = marker.longitude;
+    marker.isSpread = false;
+    marker.groupSize = 1;
+  });
+
+  return markers;
+}
+
+function createMarkerTexture(siteType, isEstimated = false) {
+  const textureKey = `${siteType}:${isEstimated ? "estimated" : "precise"}`;
+  if (textureCache.has(textureKey)) {
+    return textureCache.get(textureKey);
+  }
+
+  const color =
+    COMPUTE_CENTER_CONFIG.colors[siteType] ||
+    COMPUTE_CENTER_CONFIG.colors.gpu_cluster;
+  const canvas = document.createElement("canvas");
+  canvas.width = 128;
+  canvas.height = 128;
+  const context = canvas.getContext("2d");
+  const centerX = 64;
+  const centerY = 64;
+  const baseFill = color;
+
+  function fillPath(draw, options = {}) {
+    const { fillStyle = color } = options;
+    context.save();
+    context.fillStyle = fillStyle;
+    context.beginPath();
+    draw();
+    context.fill();
+    context.restore();
+  }
+
+  context.clearRect(0, 0, 128, 128);
+
+  if (siteType === "supercomputer") {
+    fillPath(() => {
+      context.roundRect(40, 42, 48, 30, 7);
+    }, {
+      fillStyle: baseFill,
+    });
+    fillPath(() => {
+      context.roundRect(58, 74, 12, 8, 3);
+      context.roundRect(50, 84, 28, 5, 2.5);
+    }, {
+      fillStyle: baseFill,
+    });
+  } else {
+    fillPath(() => {
+      context.ellipse(centerX, 46, 18, 8, 0, 0, Math.PI * 2);
+      context.rect(46, 46, 36, 28);
+      context.ellipse(centerX, 74, 18, 8, 0, 0, Math.PI);
+    }, {
+      fillStyle: baseFill,
+    });
+    fillPath(() => {
+      context.ellipse(centerX, 58, 12, 4.5, 0, 0, Math.PI * 2);
+      context.rect(52, 58, 24, 6);
+      context.ellipse(centerX, 64, 12, 4.5, 0, 0, Math.PI);
+    }, {
+      fillStyle: baseFill,
+    });
+  }
+
+  if (isEstimated) {
+    fillPath(() => {
+      context.arc(94, 36, 12, 0, Math.PI * 2);
+    }, {
+      fillStyle: "rgba(15,23,42,0.92)",
+    });
+    context.save();
+    context.fillStyle = "rgba(255,255,255,0.98)";
+    context.font = "bold 18px sans-serif";
+    context.textAlign = "center";
+    context.textBaseline = "middle";
+    context.fillText("?", 94, 36);
+    context.restore();
+  }
+
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.needsUpdate = true;
+  textureCache.set(textureKey, texture);
+  return texture;
+}
+
+function normalizeSiteType(siteType) {
+  return siteType === "supercomputer" ? "supercomputer" : "gpu_cluster";
+}
+
+function getBaseScale(siteType) {
+  return siteType === "supercomputer"
+    ? COMPUTE_CENTER_CONFIG.marker.supercomputerScale
+    : COMPUTE_CENTER_CONFIG.marker.gpuClusterScale;
+}
+
+function getDistanceScale(marker, camera) {
+  if (!marker || !camera || COMPUTE_CENTER_CONFIG.sizeStabilization.enabled === false) {
+    return 1;
+  }
+
+  return getSurfaceMarkerCameraScale(camera, {
+    altitudeOffset: COMPUTE_CENTER_CONFIG.altitudeOffset,
+    referenceFov: 75,
+    min: COMPUTE_CENTER_CONFIG.sizeStabilization.min,
+    max: COMPUTE_CENTER_CONFIG.sizeStabilization.max,
+  });
+}
+
+function clearGroup(group) {
+  for (let index = group.children.length - 1; index >= 0; index -= 1) {
+    const child = group.children[index];
+    child.material?.dispose?.();
+    group.remove(child);
+  }
+}
+
+function createComputeCenterMarker(markerData) {
+  const siteType = markerData.site_type;
+  const material = new THREE.SpriteMaterial({
+    map: createMarkerTexture(siteType, Boolean(markerData.is_estimated)),
+    transparent: true,
+    depthWrite: false,
+    opacity: COMPUTE_CENTER_CONFIG.marker.baseOpacity,
+  });
+  const marker = new THREE.Sprite(material);
+  const baseScale = getBaseScale(siteType);
+  marker.position.copy(
+    latLonToVector3(
+      markerData.displayLatitude,
+      markerData.displayLongitude,
+      CONFIG.earthRadius + COMPUTE_CENTER_CONFIG.altitudeOffset,
+    ),
+  );
+  marker.scale.setScalar(baseScale);
+  marker.renderOrder = 8;
+  marker.visible = showComputeCenters;
+  marker.userData = {
+    ...markerData,
+    site_type: siteType,
+    type: "compute_center",
+    baseScale,
+    state: "normal",
+    pulseOffset: Math.random() * Math.PI * 2,
+  };
+  computeCenterGroup.add(marker);
+  computeCenterMarkers.push(marker);
+  return marker;
+}
+
+export function formatComputeCenterTypeLabel(siteType) {
+  return siteType === "supercomputer" ? "超算中心" : "GPU 集群";
+}
+
+export function formatComputeCenterCapacity(markerData) {
+  const value = markerData?.capacity_value;
+  const unit = markerData?.capacity_unit;
+  if (value === null || value === undefined || value === "") return "-";
+  return `${value}${unit ? ` ${unit}` : ""}`;
+}
+
+export function formatComputeCenterUpdatedAt(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  return date.toLocaleString("zh-CN", { hour12: false });
+}
+
+export function formatComputeCenterLocationPrecision(markerData) {
+  const precision = markerData?.location_precision;
+  if (precision === "precise") return "精确坐标";
+  if (precision === "estimated_site") return "估算位置（站点级）";
+  if (precision === "estimated_country") return "估算位置（国家级）";
+  return "位置未知";
+}
+
+export function getComputeCenterLegendItems() {
+  return [
+    {
+      label: "超算中心",
+      color: COMPUTE_CENTER_CONFIG.colors.supercomputer,
+    },
+    {
+      label: "GPU 集群",
+      color: COMPUTE_CENTER_CONFIG.colors.gpu_cluster,
+    },
+  ];
+}
+
+export function getComputeCenterMarkers() {
+  return computeCenterMarkers;
+}
+
+export function getComputeCenterCount() {
+  return computeCenterMarkers.length;
+}
+
+export function getComputeCenterSupercomputerCount() {
+  return supercomputerCount;
+}
+
+export function getComputeCenterGPUClusterCount() {
+  return gpuClusterCount;
+}
+
+export function getComputeCenterStatusSummary() {
+  if (computeCenterMarkers.length === 0) return "暂无算力中心数据";
+  return `${supercomputerCount} 台超算 / ${gpuClusterCount} 个 GPU 集群`;
+}
+
+export function setComputeCenterMarkerState(marker, state = "normal") {
+  if (!marker || marker.userData?.type !== "compute_center") return;
+  marker.userData.state = state;
+}
+
+export function clearComputeCenterSelection() {
+  computeCenterMarkers.forEach((marker) => setComputeCenterMarkerState(marker, "normal"));
+}
+
+export function clearComputeCenterData(earth) {
+  computeCenterMarkers.length = 0;
+  supercomputerCount = 0;
+  gpuClusterCount = 0;
+  clearGroup(computeCenterGroup);
+  if (earth && computeCenterGroup.parent === earth) {
+    earth.remove(computeCenterGroup);
+  }
+}
+
+export function toggleComputeCenters(show) {
+  showComputeCenters = Boolean(show);
+  computeCenterGroup.visible = showComputeCenters;
+  computeCenterMarkers.forEach((marker) => {
+    marker.visible = showComputeCenters;
+  });
+}
+
+export function getShowComputeCenters() {
+  return showComputeCenters;
+}
+
+export async function loadComputeCenters(_scene, earth) {
+  const response = await fetch(PATHS.computeCentersApi);
+  if (!response.ok) {
+    throw new Error(`Compute centers HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  const features = Array.isArray(payload?.features) ? payload.features : [];
+
+  clearComputeCenterData(earth);
+
+  spreadComputeCenterPositions(
+    features
+      .map((feature) => buildComputeCenterMarkerData(feature))
+      .filter(Boolean),
+  )
+    .slice(0, COMPUTE_CENTER_CONFIG.maxRenderedMarkers)
+    .forEach((markerData) => {
+      const marker = createComputeCenterMarker(markerData);
+      if (!marker) return;
+      if (marker.userData.site_type === "supercomputer") {
+        supercomputerCount += 1;
+      } else {
+        gpuClusterCount += 1;
+      }
+    });
+
+  if (earth && !computeCenterGroup.parent) {
+    earth.add(computeCenterGroup);
+  }
+  computeCenterGroup.visible = showComputeCenters;
+
+  return {
+    totalCount: computeCenterMarkers.length,
+    supercomputerCount,
+    gpuClusterCount,
+    summary: getComputeCenterStatusSummary(),
+  };
+}
+
+export function updateComputeCenterVisualState(lockedObjectType, lockedObject, camera) {
+  const hasFocus = lockedObjectType === "compute_center" && lockedObject;
+  const now = Date.now();
+
+  computeCenterMarkers.forEach((marker) => {
+    const isLocked = lockedObjectType === "compute_center" && lockedObject === marker;
+    const state = marker.userData?.state || "normal";
+    const pulse =
+      1 +
+      COMPUTE_CENTER_CONFIG.marker.pulseAmplitude *
+        Math.sin(now * COMPUTE_CENTER_CONFIG.marker.pulseSpeed + marker.userData.pulseOffset);
+
+    let opacity = COMPUTE_CENTER_CONFIG.marker.baseOpacity;
+    let scaleMultiplier = 1;
+
+    if (isLocked) {
+      opacity = 1;
+      scaleMultiplier = COMPUTE_CENTER_CONFIG.marker.lockedScale * pulse;
+    } else if (state === "hover") {
+      opacity = 0.98;
+      scaleMultiplier = COMPUTE_CENTER_CONFIG.marker.hoverScale;
+    } else if (hasFocus) {
+      opacity = COMPUTE_CENTER_CONFIG.marker.dimmedOpacity;
+      scaleMultiplier = COMPUTE_CENTER_CONFIG.marker.dimmedScale;
+    }
+
+    const distanceScale = getDistanceScale(marker, camera);
+    marker.material.opacity = showComputeCenters ? opacity : 0;
+    marker.scale.setScalar(marker.userData.baseScale * scaleMultiplier * distanceScale);
+    marker.visible = showComputeCenters;
+  });
+}
--- a/frontend/public/earth/js/constants.js
+++ b/frontend/public/earth/js/constants.js
@@ -25,12 +25,12 @@ export const CRUISE_CONFIG = {
  maxPolledEvents: 200,
  cardAnchorXRatio: 0.68,
  cardAnchorYRatio: 0.24,
-  linkMarkerGapPx: 18,
-  linkPanelGapPx: 12,
-  linkElbowOffsetPx: 72,
-  linkAnchorHeightRatio: 0.26,
-  linkForcedBendPx: 34,
-  linkElbowDropPx: 24,
+};
+
+export const CONNECTOR_CONFIG = {
+  markerGapPx: 18,
+  panelGapPx: 12,
+  obstacleClearancePx: 8,
 };

 export const HUD_CONFIG = {
@@ -156,11 +156,43 @@ export const TERRAIN_CONFIG = {
 export const PATHS = {
  cablesApi: '/api/v1/visualization/geo/cables',
  landingPointsApi: '/api/v1/visualization/geo/landing-points',
+  computeCentersApi: '/api/v1/visualization/geo/compute-centers',
  bgpApi: '/api/v1/visualization/geo/bgp-anomalies',
  bgpIncidentsApi: '/api/v1/visualization/geo/bgp-incidents',
  bgpCollectorsApi: '/api/v1/visualization/geo/bgp-collectors',
 };

+export const COMPUTE_CENTER_CONFIG = {
+  altitudeOffset: 0.48,
+  maxRenderedMarkers: 300,
+  overlapSpread: {
+    groupPrecision: 4,
+    radius: 1.4,
+    offsetStep: 0.28,
+  },
+  marker: {
+    baseOpacity: 0.88,
+    supercomputerScale: 12,
+    gpuClusterScale: 12,
+    hoverScale: 1.16,
+    lockedScale: 1.22,
+    dimmedScale: 0.82,
+    dimmedOpacity: 0.34,
+    pulseSpeed: 0.0038,
+    pulseAmplitude: 0.03,
+  },
+  colors: {
+    supercomputer: "#38bdf8",
+    gpu_cluster: "#2dd4bf",
+    linked: "#f8fafc",
+  },
+  sizeStabilization: {
+    enabled: true,
+    min: 0.12,
+    max: 3.0,
+  },
+};
+
 // Cable colors mapping
 export const CABLE_COLORS = {
  'Americas II': 0xff4444,
--- a/frontend/public/earth/js/controls.js
+++ b/frontend/public/earth/js/controls.js
--- a/frontend/public/earth/js/info-card.js
+++ b/frontend/public/earth/js/info-card.js
@@ -4,6 +4,219 @@ import { showStatusMessage } from './ui.js';
 let currentType = null;
 let cardMounted = false;

+// ── Mobile popup ─────────────────────────────────────────────
+
+function getMobilePopupTitle(type, data) {
+  switch (type) {
+    case 'cable':         return data.name || '海缆';
+    case 'landing_point': return data.name || '登陆点';
+    case 'satellite':     return data.name || '卫星';
+    case 'bgp':           return data.anomaly_type || 'BGP事件';
+    case 'bgp_collector': return data.collector || 'BGP观测站';
+    case 'supercomputer': return data.name || '超算';
+    case 'gpu_cluster':   return data.name || 'GPU集群';
+    default:              return '详情';
+  }
+}
+
+function getMobilePopupSubtitle(type, data) {
+  switch (type) {
+    case 'cable':         return data.owner || data.status || '海缆';
+    case 'landing_point': return data.country || '登陆点';
+    case 'satellite':     return data.norad_id ? `NORAD ${data.norad_id}` : '卫星';
+    case 'bgp':           return data.severity || 'BGP路由异常';
+    case 'bgp_collector': return data.location || 'BGP观测站';
+    case 'supercomputer': return data.country || '超级计算机';
+    case 'gpu_cluster':   return data.country || 'GPU集群';
+    default:              return '';
+  }
+}
+
+function positionMobilePopup(popup, touchX, touchY, options = {}) {
+  const margin = 14;
+  const drawerClearance = 52;
+  const vpW = window.innerWidth;
+  const vpH = window.innerHeight;
+  const safeBottom = parseFloat(
+    getComputedStyle(document.documentElement).getPropertyValue('--safe-bottom')
+  ) || 0;
+  const bottomBound = vpH - drawerClearance - safeBottom;
+
+  // Measure actual popup size (it's rendered but invisible via opacity)
+  const popW = popup.offsetWidth || 200;
+  const popH = popup.offsetHeight || 68;
+
+  if (options.absolute === true) {
+    const left = Math.max(margin, Math.min(touchX, vpW - popW - margin));
+    const top = Math.max(margin, Math.min(touchY, bottomBound - popH - margin));
+    popup.style.left = `${left}px`;
+    popup.style.top  = `${top}px`;
+    return;
+  }
+
+  const gap = 22;
+  const spaceRight  = vpW - touchX;
+  const spaceLeft   = touchX;
+  const spaceBottom = bottomBound - touchY;
+  const spaceTop    = touchY;
+
+  let left, top;
+
+  // Horizontal: side with more room
+  if (spaceRight >= popW + gap + margin) {
+    left = touchX + gap;
+  } else if (spaceLeft >= popW + gap + margin) {
+    left = touchX - gap - popW;
+  } else {
+    left = Math.max(margin, Math.min(touchX - popW / 2, vpW - popW - margin));
+  }
+
+  // Vertical: prefer above touch, then below
+  if (spaceTop >= popH + gap + margin) {
+    top = touchY - gap - popH;
+  } else if (spaceBottom >= popH + gap + margin) {
+    top = touchY + gap;
+  } else {
+    top = Math.max(margin, Math.min(touchY - popH / 2, bottomBound - popH - margin));
+  }
+
+  left = Math.max(margin, Math.min(left, vpW - popW - margin));
+  top  = Math.max(margin, Math.min(top, bottomBound - popH - margin));
+
+  popup.style.left = `${left}px`;
+  popup.style.top  = `${top}px`;
+}
+
+let popupShowToken = 0;
+
+function showMobilePopup(type, data, x, y, options = {}) {
+  // Require coordinates — skip if called without position (e.g. from handleCableClick)
+  if (x == null || y == null) return;
+
+  const popup  = document.getElementById('earth-mobile-popup');
+  const iconEl = document.getElementById('earth-mobile-popup-icon');
+  const titleEl = document.getElementById('earth-mobile-popup-title');
+  const subEl  = document.getElementById('earth-mobile-popup-sub');
+  if (!popup || !iconEl || !titleEl || !subEl) return;
+
+  const config = CARD_CONFIG[type];
+  if (!config) return;
+
+  iconEl.textContent  = config.icon;
+  titleEl.textContent = getMobilePopupTitle(type, data);
+  subEl.textContent   = getMobilePopupSubtitle(type, data);
+
+  // Invalidate any in-flight hide listener
+  popupShowToken += 1;
+  const token = popupShowToken;
+
+  popup.dataset.dockSide = options.dockSide === 'right' ? 'right' : 'left';
+  popup.classList.toggle('earth-mobile-popup--anchor-stable', options.anchorStable === true);
+  popup.removeAttribute('hidden');
+  popup.classList.remove('is-visible');
+
+  requestAnimationFrame(() => {
+    positionMobilePopup(popup, x, y, options);
+    if (options.reveal === false) {
+      return;
+    }
+    if (token !== popupShowToken) return; // superseded
+    void popup.getBoundingClientRect();
+    popup.classList.add('is-visible');
+  });
+}
+
+function hideMobilePopup() {
+  const popup = document.getElementById('earth-mobile-popup');
+  if (!popup) return;
+  popupShowToken += 1; // invalidate any pending show
+  popup.classList.remove('is-visible');
+  popup.classList.remove('earth-mobile-popup--anchor-stable');
+  delete popup.dataset.dockSide;
+  popup.addEventListener('transitionend', () => {
+    if (!popup.classList.contains('is-visible')) {
+      popup.setAttribute('hidden', '');
+    }
+  }, { once: true });
+}
+
+let popupClickBound = false;
+function ensurePopupClickHandler() {
+  if (popupClickBound) return;
+  popupClickBound = true;
+  const popup = document.getElementById('earth-mobile-popup');
+  if (!popup) return;
+
+  let dragPointerId = null;
+  let startX = 0, startY = 0;
+  let startLeft = 0, startTop = 0;
+  let dragged = false;
+  const DRAG_THRESHOLD = 10;
+
+  const emitDragEvent = (dragging) => {
+    const rect = popup.getBoundingClientRect();
+    window.dispatchEvent(new CustomEvent('earth:info-card-drag', {
+      detail: {
+        left: rect.left,
+        top: rect.top,
+        width: rect.width,
+        height: rect.height,
+        dragging,
+      },
+    }));
+  };
+
+  popup.addEventListener('pointerdown', (e) => {
+    if (e.button > 0) return;
+    e.stopPropagation();
+    dragPointerId = e.pointerId;
+    startX = e.clientX;
+    startY = e.clientY;
+    const rect = popup.getBoundingClientRect();
+    startLeft = rect.left;
+    startTop  = rect.top;
+    dragged = false;
+  });
+
+  // Track drag at document level so pointer can leave popup bounds
+  document.addEventListener('pointermove', (e) => {
+    if (e.pointerId !== dragPointerId) return;
+    const dx = e.clientX - startX;
+    const dy = e.clientY - startY;
+    if (Math.hypot(dx, dy) < DRAG_THRESHOLD) return;
+    dragged = true;
+    e.stopPropagation();
+    const margin = 8;
+    const left = Math.max(margin, Math.min(startLeft + dx, window.innerWidth  - popup.offsetWidth  - margin));
+    const top  = Math.max(margin, Math.min(startTop  + dy, window.innerHeight - popup.offsetHeight - margin));
+    popup.style.left = `${left}px`;
+    popup.style.top  = `${top}px`;
+    emitDragEvent(true);
+  });
+
+  document.addEventListener('pointerup', (e) => {
+    if (e.pointerId !== dragPointerId) return;
+    const wasDragged = dragged;
+    dragPointerId = null;
+    dragged = false;
+    emitDragEvent(false);
+    if (!wasDragged) {
+      window.dispatchEvent(new CustomEvent('earth:open-details-tab'));
+    }
+  });
+
+  document.addEventListener('pointercancel', (e) => {
+    if (e.pointerId === dragPointerId) {
+      dragPointerId = null;
+      dragged = false;
+      emitDragEvent(false);
+    }
+  });
+
+  // Block click from bubbling to document (which would close the drawer)
+  popup.addEventListener('click', (e) => e.stopPropagation());
+}
+
 const CARD_CONFIG = {
  cable: {
    icon: '🛥️',
@@ -91,15 +304,22 @@ const CARD_CONFIG = {
  },
  supercomputer: {
    icon: '🖥️',
-    title: '超算详情',
+    title: '超算中心详情',
    className: 'supercomputer',
    fields: [
      { key: 'name', label: '名称' },
+      { key: 'site_type_label', label: '类型' },
      { key: 'rank', label: '排名' },
-      { key: 'r_max', label: 'Rmax', unit: 'GFlops' },
-      { key: 'r_peak', label: 'Rpeak', unit: 'GFlops' },
+      { key: 'capacity', label: '实测算力' },
+      { key: 'vendor', label: '厂商' },
+      { key: 'operator', label: '运营方' },
+      { key: 'cores', label: '核心数' },
+      { key: 'power', label: '功耗', unit: 'kW' },
      { key: 'country', label: '国家' },
-      { key: 'city', label: '城市' }
+      { key: 'city', label: '城市' },
+      { key: 'location_precision_label', label: '位置精度' },
+      { key: 'source', label: '来源' },
+      { key: 'updated_at', label: '更新时间' }
    ]
  },
  gpu_cluster: {
@@ -108,8 +328,17 @@ const CARD_CONFIG = {
    className: 'gpu_cluster',
    fields: [
      { key: 'name', label: '名称' },
+      { key: 'site_type_label', label: '类型' },
+      { key: 'capacity', label: '估算算力' },
+      { key: 'gpu_count', label: 'GPU 数量' },
+      { key: 'gpu_type', label: 'GPU 型号' },
+      { key: 'vendor', label: '芯片/平台' },
+      { key: 'operator', label: '运营方' },
      { key: 'country', label: '国家' },
-      { key: 'city', label: '城市' }
+      { key: 'city', label: '城市' },
+      { key: 'location_precision_label', label: '位置精度' },
+      { key: 'source', label: '来源' },
+      { key: 'updated_at', label: '更新时间' }
    ]
  }
 };
@@ -126,19 +355,47 @@ function setupInfoCardDrag(panel) {
  if (!handle) return;

  let isDragging = false;
+  let activePointerId = null;
  let startPointerX = 0;
  let startPointerY = 0;
  let startLeft = 0;
  let startTop = 0;

-  const stopDragging = () => {
+  const emitDragEvent = () => {
+    const rect = panel.getBoundingClientRect();
+    window.dispatchEvent(
+      new CustomEvent('earth:info-card-drag', {
+        detail: {
+          left: rect.left,
+          top: rect.top,
+          width: rect.width,
+          height: rect.height,
+          dragging: isDragging,
+        },
+      })
+    );
+  };
+
+  const stopDragging = (event) => {
+    if (
+      event &&
+      activePointerId !== null &&
+      "pointerId" in event &&
+      event.pointerId !== activePointerId
+    ) {
+      return;
+    }
    isDragging = false;
+    activePointerId = null;
    panel.classList.remove('is-dragging');
    document.body.style.userSelect = '';
+    emitDragEvent();
  };

  const onMove = (event) => {
    if (!isDragging) return;
+    if (activePointerId !== null && event.pointerId !== activePointerId) return;
+    event.preventDefault();
    const appRect = app.getBoundingClientRect();
    const panelRect = panel.getBoundingClientRect();
    const nextLeft = Math.min(
@@ -151,11 +408,14 @@ function setupInfoCardDrag(panel) {
    );
    panel.style.left = `${nextLeft}px`;
    panel.style.top = `${nextTop}px`;
+    emitDragEvent();
  };

  handle.addEventListener('pointerdown', (event) => {
    if (event.target.closest('.hud-panel-close, .info-card-close')) return;
+    event.preventDefault();
    isDragging = true;
+    activePointerId = event.pointerId;
    startPointerX = event.clientX;
    startPointerY = event.clientY;
    const appRect = app.getBoundingClientRect();
@@ -169,11 +429,14 @@ function setupInfoCardDrag(panel) {
    panel.classList.add('is-dragging');
    document.body.style.userSelect = 'none';
    handle.setPointerCapture?.(event.pointerId);
+    emitDragEvent();
  });

-  handle.addEventListener('pointermove', onMove);
-  handle.addEventListener('pointerup', stopDragging);
-  handle.addEventListener('pointercancel', stopDragging);
+  // Listen in capture phase so card-level stopPropagation used to shield the
+  // globe canvas does not swallow the drag stream before we can reposition.
+  window.addEventListener('pointermove', onMove, { passive: false, capture: true });
+  window.addEventListener('pointerup', stopDragging, { capture: true });
+  window.addEventListener('pointercancel', stopDragging, { capture: true });
  handle.addEventListener('lostpointercapture', stopDragging);
 }

@@ -187,6 +450,8 @@ function mountCard() {
  panel.id = 'info-panel';
  panel.className = 'hud-panel hud-panel-info';
  panel.setAttribute('aria-live', 'polite');
+  panel.setAttribute('aria-hidden', 'true');
+  panel.setAttribute('hidden', '');
  panel.innerHTML = `
    <div id="info-card" class="info-card">
      <div class="info-card-header hud-panel-drag-handle">
@@ -252,6 +517,13 @@ function mountCard() {

 function positionPanel(panel, x, y, options = {}) {
  if (!panel) return;
+  if (document.body.classList.contains('layout-mode-mobile')) {
+    panel.style.left = '8px';
+    panel.style.right = '8px';
+    panel.style.top = 'auto';
+    panel.style.bottom = 'calc(84px + env(safe-area-inset-bottom, 0px))';
+    return;
+  }
  const margin = 12;
  const offset = 14;
  const vpW = window.innerWidth;
@@ -294,13 +566,35 @@ function positionPanel(panel, x, y, options = {}) {
 function showPanel(x, y, options = {}) {
  const panel = getPanel();
  if (!panel) return;
+  panel.classList.toggle('hud-panel-info--anchor-stable', options.anchorStable === true);
+  panel.removeAttribute('hidden');
+  panel.setAttribute('aria-hidden', 'false');
  if (x != null && y != null) positionPanel(panel, x, y, options);
-  panel.classList.add('is-visible');
+  if (options.reveal === false) {
+    panel.classList.remove('is-visible');
+    return;
+  }
+  requestAnimationFrame(() => {
+    panel.classList.add('is-visible');
+  });
+  document.body.classList.add('earth-info-open');
+  window.dispatchEvent(
+    new CustomEvent('earth:info-card-visibility-change', { detail: { visible: true } })
+  );
 }

 function hidePanel() {
  const panel = getPanel();
-  if (panel) panel.classList.remove('is-visible');
+  if (panel) {
+    panel.classList.remove('is-visible');
+    panel.classList.remove('hud-panel-info--anchor-stable');
+    panel.setAttribute('aria-hidden', 'true');
+    panel.setAttribute('hidden', '');
+  }
+  document.body.classList.remove('earth-info-open');
+  window.dispatchEvent(
+    new CustomEvent('earth:info-card-visibility-change', { detail: { visible: false } })
+  );
 }

 // No-op: event binding now happens lazily in mountCard()
@@ -320,6 +614,51 @@ export function showInfoCard(type, data, options = {}) {
    return;
  }

+  if (document.body.classList.contains('layout-mode-mobile')) {
+    currentType = type;
+
+    // Fill drawer details slot (accessible when user taps popup → opens details tab)
+    const icon = document.getElementById('mobile-info-card-icon');
+    const title = document.getElementById('mobile-info-card-title');
+    const typeLabel = document.getElementById('mobile-info-card-type');
+    const content = document.getElementById('mobile-info-card-content');
+
+    if (icon) icon.textContent = config.icon;
+    if (title) title.textContent = config.title;
+    if (typeLabel) typeLabel.textContent = type.replaceAll('_', ' ');
+
+    if (content) {
+      let html = '';
+      for (const field of config.fields) {
+        let value = data[field.key];
+        if (value === undefined || value === null || value === '') {
+          value = '-';
+        } else if (typeof value === 'number') {
+          value = value.toLocaleString();
+        }
+        if (field.unit && value !== '-') value = value + ' ' + field.unit;
+        html += `
+          <div class="earth-mobile-detail-row">
+            <span class="earth-mobile-detail-row-label">${field.label}</span>
+            <span class="earth-mobile-detail-row-value">${value}</span>
+          </div>
+        `;
+      }
+      content.innerHTML = html;
+    }
+
+    // Show the floating mini popup near the touch point (requires coordinates)
+    if (options.x != null && options.y != null) {
+      ensurePopupClickHandler();
+      showMobilePopup(type, data, options.x, options.y, options);
+      document.body.classList.add('earth-info-open');
+      window.dispatchEvent(
+        new CustomEvent('earth:info-card-visibility-change', { detail: { visible: true } })
+      );
+    }
+    return;
+  }
+
  mountCard();

  currentType = type;
@@ -359,6 +698,15 @@ export function showInfoCard(type, data, options = {}) {
 }

 export function hideInfoCard() {
+  if (document.body.classList.contains('layout-mode-mobile')) {
+    hideMobilePopup();
+    document.body.classList.remove('earth-info-open');
+    window.dispatchEvent(
+      new CustomEvent('earth:info-card-visibility-change', { detail: { visible: false } })
+    );
+    currentType = null;
+    return;
+  }
  hidePanel();
  currentType = null;
 }
--- a/frontend/public/earth/js/layer-startup-tasks.js
+++ b/frontend/public/earth/js/layer-startup-tasks.js
@@ -14,6 +14,10 @@ import {
  loadBGPAnomalies,
  toggleBGP,
 } from "./bgp.js";
+import {
+  loadComputeCenters,
+  toggleComputeCenters,
+} from "./compute-centers.js";

 /**
 * Layer startup task registry.
@@ -70,6 +74,7 @@ function registerBuiltinLayerStartupTasks() {
  startupTaskRegistry.clear();
  registerCableStartupTask();
  registerSatelliteStartupTask();
+  registerComputeCenterStartupTask();
  registerBGPStartupTask();
 }

@@ -171,4 +176,26 @@ function registerBGPStartupTask() {
  });
 }

+function registerComputeCenterStartupTask() {
+  registerLayerStartupTask("computeCenters", (context) => async (layer) => {
+    context.setLoadingMessage(
+      resolveStartupMessage(layer, "load", "正在加载算力中心..."),
+    );
+    await context.yieldFrame(12);
+    try {
+      const computeCenterResult = await loadComputeCenters(context.scene, context.earth);
+      if (!context.isCancelled()) {
+        toggleComputeCenters(context.getShowComputeCenters());
+        context.updateComputeCenterHud(computeCenterResult);
+        context.setLegendItems("computeCenters", context.getComputeCenterLegendItems());
+        context.refreshLegend();
+      }
+    } catch (error) {
+      context.reportError(layer?.startupLabel || layer?.label || "算力中心", error);
+    }
+    if (context.isCancelled()) return;
+    await context.yieldFrame(16);
+  });
+}
+
 registerBuiltinLayerStartupTasks();
--- a/frontend/public/earth/js/legend.js
+++ b/frontend/public/earth/js/legend.js
@@ -1,9 +1,10 @@
 import { createHUDPanel } from "./hud-panels.js";

 const LEGEND_MODES = {
-  cables:     { title: "海缆" },
-  satellites: { title: "卫星" },
-  bgp:        { title: "BGP" },
+  cables:         { title: "海缆" },
+  satellites:     { title: "卫星" },
+  computeCenters: { title: "算力" },
+  bgp:            { title: "BGP" },
 };

 let currentLegendMode = "cables";
@@ -11,6 +12,7 @@ let legendPanel = null;
 let legendItemsByMode = {
  cables: [],
  satellites: [],
+  computeCenters: [],
  bgp: [],
 };

@@ -62,17 +64,18 @@ export function setLegendItems(mode, items) {
 }

 function syncCurrentLabel(mode) {
-  const labelEl = document.getElementById("legend-current-label");
-  if (!labelEl) return;
-  labelEl.textContent = LEGEND_MODES[mode]?.title || LEGEND_MODES.cables.title;
+  const nextLabel = LEGEND_MODES[mode]?.title || LEGEND_MODES.cables.title;
+  [document.getElementById("legend-current-label"), document.getElementById("mobile-situation-legend-mode")]
+    .forEach((labelEl) => {
+      if (labelEl) {
+        labelEl.textContent = nextLabel;
+      }
+    });
 }

 function renderLegend(mode) {
-  const listEl = document.querySelector("#legend .legend-list");
-  if (!listEl) return;
-
  const items = legendItemsByMode[mode] || [];
-  listEl.innerHTML = items
+  const html = items
    .map(
      (item) => `
        <div class="legend-item">
@@ -81,4 +84,14 @@ function renderLegend(mode) {
        </div>`,
    )
    .join("");
+
+  const desktopList = document.querySelector("#legend .legend-list");
+  if (desktopList) {
+    desktopList.innerHTML = html;
+  }
+
+  const mobileList = document.getElementById("mobile-situation-legend-list");
+  if (mobileList) {
+    mobileList.innerHTML = html;
+  }
 }
--- a/frontend/public/earth/js/main.js
+++ b/frontend/public/earth/js/main.js
@@ -19,6 +19,7 @@ import {
  updateCoordinatesDisplay,
  updateZoomDisplay,
  updateEarthStats,
+  setEarthStatValue,
  setLoading,
  setLoadingMessage,
  showTooltip,
@@ -127,6 +128,22 @@ import {
  showBGPEventOverlay,
  showBGPCollectorCoverageOverlay,
 } from "./bgp.js";
+import {
+  clearComputeCenterData,
+  clearComputeCenterSelection,
+  formatComputeCenterCapacity,
+  formatComputeCenterLocationPrecision,
+  formatComputeCenterTypeLabel,
+  formatComputeCenterUpdatedAt,
+  getComputeCenterCount,
+  getComputeCenterLegendItems,
+  getComputeCenterMarkers,
+  getShowComputeCenters,
+  loadComputeCenters,
+  setComputeCenterMarkerState,
+  toggleComputeCenters,
+  updateComputeCenterVisualState,
+} from "./compute-centers.js";
 import {
  setupControls,
  getAutoRotate,
@@ -137,6 +154,7 @@ import {
  applyImmediateView,
  focusEarthView,
  getZoomLevel,
+  setZoomLevel,
  teardownControls,
 } from "./controls.js";
 import {
@@ -175,6 +193,7 @@ let targetRotation = { x: 0, y: 0 };
 let inertialVelocity = { x: 0, y: 0 };
 let hoveredCable = null;
 let hoveredBGP = null;
+let hoveredComputeCenter = null;
 let hoveredSatellite = null;
 let hoveredSatelliteIndex = null;
 let lockedSatellite = null;
@@ -203,9 +222,14 @@ let satelliteToggleToken = 0;
 let satelliteHydrationToken = 0;
 let sceneLights = null;
 let cruisePollTimerId = null;
-let cruiseConnector = null;
+let calloutConnector = null;
 let cruiseBGPAdapter = null;
 let cruiseSequencer = null;
+let activeDragPointerId = null;
+let activeTouchPoints = new Map();
+let pinchGesture = null;
+let pointerDragDistance = 0;
+let suppressNextClick = false;

 const clock = new THREE.Clock();
 const interactionRaycaster = new THREE.Raycaster();
@@ -215,6 +239,8 @@ const scratchCableCenter = new THREE.Vector3();
 const scratchCableDirection = new THREE.Vector3();
 const scratchBGPDirection = new THREE.Vector3();
 const scratchBGPWorldPosition = new THREE.Vector3();
+const scratchComputeCenterDirection = new THREE.Vector3();
+const scratchComputeCenterWorldPosition = new THREE.Vector3();
 const scratchViewCenterWorld = new THREE.Vector3();

 const cleanupFns = [];
@@ -226,6 +252,8 @@ const ACTIVE_BGP_TOOLTIP_TEXT = "隐藏BGP观测";
 const TOOLTIP_CURSOR_OFFSET = 14;   // px offset from cursor for hover tooltips
 const TOOLTIP_COORDS_OFFSET = 10;   // px offset for earth-coordinate tooltip
 const RELATED_SATELLITE_HIGHLIGHT_COLOR = "#7dd3fc";
+const DRAG_POINTER_THRESHOLD_PX = 8;
+const GLOBE_DRAGGING_CLASS = "is-globe-dragging";
 const HUD_INTERACTIVE_SELECTORS = [
  ".earth-left-column",
  ".earth-left-column *",
@@ -239,6 +267,8 @@ const HUD_INTERACTIVE_SELECTORS = [
  "#earth-stats *",
  "#media-panel",
  "#media-panel *",
+  "#mobile-drawer-shell",
+  "#mobile-drawer-shell *",
 ];

 function bindListener(target, eventName, handler, options) {
@@ -266,6 +296,17 @@ function isEventOnHud(event) {
  return HUD_INTERACTIVE_SELECTORS.some((selector) => target.closest(selector));
 }

+function clearDocumentSelection() {
+  const selection = window.getSelection?.();
+  if (!selection || selection.rangeCount === 0) return;
+  selection.removeAllRanges();
+}
+
+function setGlobeDraggingUiState(active) {
+  document.body.classList.toggle(GLOBE_DRAGGING_CLASS, active);
+  document.documentElement.classList.toggle(GLOBE_DRAGGING_CLASS, active);
+}
+
 function getDragRotationFactor() {
  const zoom = Math.max(getZoomLevel(), 0.01);
  const scale = THREE.MathUtils.clamp(
@@ -276,6 +317,13 @@ function getDragRotationFactor() {
  return CONFIG.dragRotationFactorBase * scale;
 }

+function getTouchDistance(firstPoint, secondPoint) {
+  return Math.hypot(
+    secondPoint.clientX - firstPoint.clientX,
+    secondPoint.clientY - firstPoint.clientY,
+  );
+}
+
 function disposeMaterial(material) {
  if (!material) return;
  if (Array.isArray(material)) {
@@ -321,6 +369,7 @@ function disposeSceneObject(object) {
 function clearRuntimeSelection() {
  hoveredCable = null;
  hoveredBGP = null;
+  hoveredComputeCenter = null;
  hoveredSatellite = null;
  hoveredSatelliteIndex = null;
  lockedObject = null;
@@ -336,6 +385,7 @@ export function clearLockedObject() {
  clearAllCableStates();
  clearCableSelection();
  clearBGPSelection();
+  clearComputeCenterSelection();
  clearRelatedSatelliteHighlights();
  setSatelliteRingState(null, "none", null);
  clearRuntimeSelection();
@@ -371,6 +421,14 @@ function isSameBGPMarker(marker1, marker2) {
  return false;
 }

+function isSameComputeCenter(marker1, marker2) {
+  if (!marker1 || !marker2) return false;
+  if (marker1.userData?.type !== "compute_center" || marker2.userData?.type !== "compute_center") {
+    return false;
+  }
+  return marker1.userData?.id === marker2.userData?.id;
+}
+
 function getBGPCollectorMarkerByName(collector) {
  return getBGPCollectorMarkers().find(
    (marker) => marker.userData?.collector === collector,
@@ -390,9 +448,19 @@ function resetTransientBGPStates() {
  });
 }

+function resetTransientComputeCenterStates() {
+  getComputeCenterMarkers().forEach((marker) => {
+    if (marker !== lockedObject) {
+      setComputeCenterMarkerState(marker, "normal");
+    }
+  });
+}
+
 function clearTransientHoverState() {
  resetTransientBGPStates();
+  resetTransientComputeCenterStates();
  hoveredBGP = null;
+  hoveredComputeCenter = null;

  if (hoveredCable && !isSameCable(hoveredCable, lockedObject)) {
    setCableState(hoveredCable.userData.cableId, CABLE_STATE.NORMAL);
@@ -428,6 +496,18 @@ function applyBGPHoverState(marker) {
  }
 }

+function applyComputeCenterHoverState(marker) {
+  resetTransientComputeCenterStates();
+  if (!marker) {
+    hoveredComputeCenter = null;
+    return;
+  }
+  hoveredComputeCenter = marker;
+  if (marker !== lockedObject) {
+    setComputeCenterMarkerState(marker, "hover");
+  }
+}
+
 function getPrimaryBGPHoverTarget(bgpAnomalyIntersects, bgpCollectorIntersects) {
  if (bgpAnomalyIntersects.length > 0) {
    return bgpAnomalyIntersects[0].object;
@@ -508,6 +588,40 @@ function getSatelliteBriefHtml(props) {
  return `<strong>${name}</strong>${id ? `<br>${id}` : ""}`;
 }

+function showComputeCenterInfo(marker, coords) {
+  const siteType = marker.userData?.site_type === "supercomputer"
+    ? "supercomputer"
+    : "gpu_cluster";
+  setLegendMode("computeCenters");
+  showInfoCard(siteType, {
+    name: marker.userData?.name || "-",
+    site_type_label: formatComputeCenterTypeLabel(siteType),
+    rank: marker.userData?.rank ?? "-",
+    capacity: formatComputeCenterCapacity(marker.userData),
+    vendor: marker.userData?.vendor || "-",
+    operator: marker.userData?.operator || "-",
+    gpu_count: marker.userData?.gpu_count ?? "-",
+    gpu_type: marker.userData?.gpu_type || "-",
+    cores: marker.userData?.cores ?? "-",
+    power: marker.userData?.power ?? "-",
+    country: marker.userData?.country || "-",
+    city: marker.userData?.city || "-",
+    location_precision_label: formatComputeCenterLocationPrecision(marker.userData),
+    source: marker.userData?.source || "-",
+    updated_at: formatComputeCenterUpdatedAt(marker.userData?.updated_at),
+  }, coords);
+}
+
+function getComputeCenterBriefHtml(marker) {
+  const name = marker.userData?.name || "算力中心";
+  const type = formatComputeCenterTypeLabel(marker.userData?.site_type);
+  const location = [marker.userData?.city, marker.userData?.country]
+    .filter(Boolean)
+    .join(", ");
+  const precision = marker.userData?.is_estimated ? " · 估算位置" : "";
+  return `<strong>${name}</strong><br>${type}${location ? ` · ${location}` : ""}${precision}`;
+}
+
 function showBGPInfo(marker, coords) {
  setLegendMode("bgp");
  const impactedRegions =
@@ -683,6 +797,13 @@ function getBGPFocusCoords(marker) {
  return { lat, lon };
 }

+function getComputeCenterFocusCoords(marker) {
+  const lat = marker?.userData?.latitude;
+  const lon = marker?.userData?.longitude;
+  if (typeof lat !== "number" || typeof lon !== "number") return null;
+  return { lat, lon };
+}
+
 async function focusSearchTarget(coords, zoom = Math.max(getZoomLevel(), 1.12)) {
  if (!coords || !camera) return;
  await focusEarthView(camera, {
@@ -830,6 +951,29 @@ async function focusSearchBGPMarker(marker) {
  }
 }

+async function focusSearchComputeCenter(marker) {
+  if (!getShowComputeCenters()) {
+    toggleComputeCenters(true);
+  }
+  interruptCruisePresentation({ resetLoop: true });
+  clearLockedObject();
+  setAutoRotate(false);
+
+  const coords = getComputeCenterFocusCoords(marker);
+  if (coords) {
+    await focusSearchTarget(coords, Math.max(getZoomLevel(), 1.16));
+  }
+
+  setComputeCenterMarkerState(marker, "locked");
+  lockedObject = marker;
+  lockedObjectType = "compute_center";
+  showComputeCenterInfo(marker, getSearchCardCoords());
+  showStatusMessage(
+    `已定位算力中心：${marker.userData?.name || "未知节点"}`,
+    "info",
+  );
+}
+
 function resolveEarthSearchResults(query) {
  const results = [];
  const normalizedQuery = query.trim().toLowerCase();
@@ -968,6 +1112,34 @@ function resolveEarthSearchResults(query) {
    });
  });

+  getComputeCenterMarkers().forEach((marker) => {
+    const score = computeSearchScore(
+      normalizedQuery,
+      marker.userData?.name,
+      marker.userData?.country,
+      marker.userData?.city,
+      marker.userData?.operator,
+      marker.userData?.vendor,
+      marker.userData?.site_type,
+      "算力中心 compute center gpu 超算",
+    );
+    if (score < 0) return;
+    results.push({
+      id: `compute:${marker.userData?.id || marker.uuid}`,
+      kind: "compute_center",
+      icon: "memory",
+      typeLabel: "算力中心",
+      title: marker.userData?.name || "未知算力中心",
+      subtitle: [
+        formatComputeCenterTypeLabel(marker.userData?.site_type),
+        marker.userData?.city,
+        marker.userData?.country,
+      ].filter(Boolean).join(" · ") || "算力基础设施",
+      score,
+      entity: marker,
+    });
+  });
+
  return results
    .sort((left, right) => {
      if (right.score !== left.score) return right.score - left.score;
@@ -993,6 +1165,10 @@ async function handleSearchSelection(result) {
  }
  if (result.kind === "bgp" || result.kind === "bgp_collector") {
    await focusSearchBGPMarker(result.entity);
+    return;
+  }
+  if (result.kind === "compute_center") {
+    await focusSearchComputeCenter(result.entity);
  }
 }

@@ -1006,6 +1182,19 @@ function getBGPStatusText(bgpResult) {
  return "当前无活跃事件";
 }

+function updateComputeCenterHud(computeCenterResult) {
+  const computeBtn = document.getElementById("toggle-compute-centers");
+  if (computeBtn) {
+    computeBtn.classList.add("active");
+    const tooltip = computeBtn.querySelector(".earth-toolbar-tooltip");
+    if (tooltip) {
+      tooltip.textContent = "隐藏算力中心";
+    }
+  }
+
+  setEarthStatValue("compute-center-count", `${computeCenterResult.totalCount} 个`);
+}
+
 function updateBGPHud(bgpResult) {
  const bgpBtn = document.getElementById("toggle-bgp");
  if (bgpBtn) {
@@ -1016,27 +1205,16 @@ function updateBGPHud(bgpResult) {
    }
  }

-  const bgpCountEl = document.getElementById("bgp-anomaly-count");
-  if (bgpCountEl) {
-    bgpCountEl.textContent = `${bgpResult.totalCount} 起`;
-  }
-
-  const bgpCollectorEl = document.getElementById("bgp-collector-count");
-  if (bgpCollectorEl) {
-    bgpCollectorEl.textContent = `${bgpResult.collectorCount} 个`;
-  }
-
-  const bgpStatusEl = document.getElementById("bgp-status-summary");
-  if (bgpStatusEl) {
-    bgpStatusEl.textContent = getBGPStatusText(bgpResult);
-  }
+  setEarthStatValue("bgp-anomaly-count", `${bgpResult.totalCount} 起`);
+  setEarthStatValue("bgp-collector-count", `${bgpResult.collectorCount} 个`);
+  setEarthStatValue("bgp-status-summary", getBGPStatusText(bgpResult));
 }

-function ensureCruiseConnector() {
-  if (!cruiseConnector) {
-    cruiseConnector = new CalloutConnector({ className: "info-card-cruise-link" });
+function ensureCalloutConnector() {
+  if (!calloutConnector) {
+    calloutConnector = new CalloutConnector({ className: "callout-connector" });
  }
-  return cruiseConnector;
+  return calloutConnector;
 }

 function ensureBGPCruiseAdapter() {
@@ -1045,7 +1223,7 @@ function ensureBGPCruiseAdapter() {
  cruiseBGPAdapter = createBGPCruiseAdapter({
    camera,
    getMarkers: () => getBGPAnomalyMarkers(),
-    connector: ensureCruiseConnector(),
+    connector: ensureCalloutConnector(),
    focusView: (options) => focusEarthView(camera, options),
    setMarkerLocked: (marker) => {
      setLegendMode("bgp");
@@ -1064,7 +1242,8 @@ function ensureBGPCruiseAdapter() {
    showMarkerInfo: showBGPInfo,
    hideInfo: hideInfoCard,
    isInfoVisible: () =>
-      document.getElementById("info-panel")?.classList.contains("is-visible") === true,
+      document.getElementById("info-panel")?.classList.contains("is-visible") === true ||
+      document.getElementById("earth-mobile-popup")?.classList.contains("is-visible") === true,
    getLockedObject: () => lockedObject,
    refreshMarkers: async () => {
      const bgpResult = await loadBGPAnomalies(scene, getEarth());
@@ -1392,10 +1571,7 @@ function updateSatelliteToggleUi(enabled, satelliteCount = getSatelliteCount())
    });
  }

-  const satelliteCountEl = document.getElementById("satellite-count");
-  if (satelliteCountEl) {
-    satelliteCountEl.textContent = `${satelliteCount} 颗`;
-  }
+  setEarthStatValue("satellite-count", `${satelliteCount} 颗`);
 }

 function updateCableToggleUi(enabled) {
@@ -1408,15 +1584,8 @@ function updateCableToggleUi(enabled) {
    });
  }

-  const cableCountEl = document.getElementById("cable-count");
-  if (cableCountEl) {
-    cableCountEl.textContent = `${getCableLines().length}个`;
-  }
-
-  const landingPointCountEl = document.getElementById("landing-point-count");
-  if (landingPointCountEl) {
-    landingPointCountEl.textContent = `${getLandingPoints().length}个`;
-  }
+  setEarthStatValue("cable-count", `${getCableLines().length}个`);
+  setEarthStatValue("landing-point-count", `${getLandingPoints().length}个`);
 }

 async function ensureCablesEnabled() {
@@ -1533,8 +1702,8 @@ function disableSatellites() {
 function updateStatsSummary() {
  updateEarthStats({
    cableCount: getCableLines().length,
-    landingPointCount:
-      document.getElementById("landing-point-count")?.textContent || 0,
+    landingPointCount: getLandingPoints().length,
+    computeCenterCount: `${getComputeCenterCount()} 个`,
    bgpAnomalyCount: `${getBGPCount()} 条`,
    bgpCollectorCount: `${getBGPCollectorCount()} 个`,
    bgpStatusSummary: getBGPStatusSummary(),
@@ -1610,6 +1779,7 @@ export function init() {
  initLegend();
  setLegendItems("cables", getCableLegendItems());
  setLegendItems("satellites", getSatelliteLegendItems());
+  setLegendItems("computeCenters", getComputeCenterLegendItems());
  setLegendItems("bgp", getBGPLegendItems());
  const earthObj = createEarth(scene);
  applyImmediateView(earthObj, camera);
@@ -1767,6 +1937,7 @@ async function loadData() {
  clearEarthTexture();
  clearBGPData(earth);
  clearCableData(earth);
+  clearComputeCenterData(earth);
  clearSatelliteData();

  setLoadingMessage("正在初始化...");
@@ -1794,9 +1965,12 @@ async function loadData() {
    yieldFrame,
    refreshLegend,
    setLegendItems,
+    getComputeCenterLegendItems,
    updateCableToggleUi,
    updateSatelliteToggleUi,
+    updateComputeCenterHud,
    updateBGPHud,
+    getShowComputeCenters,
    getShowBGP,
    getInitialSatelliteLoadLimit,
    shouldHydrateFullSatelliteSet,
@@ -1843,6 +2017,7 @@ async function loadData() {
  updateSatelliteToggleUi(satellitesEnabled);
  setLegendItems("cables", getCableLegendItems());
  setLegendItems("satellites", getSatelliteLegendItems());
+  setLegendItems("computeCenters", getComputeCenterLegendItems());
  setLegendItems("bgp", getBGPLegendItems());
  refreshLegend();
  setLoading(false);
@@ -1974,23 +2149,29 @@ export async function setSatellitesEnabled(

 function setupEventListeners() {
  const handleResize = () => onWindowResize();
-  const handleMouseMove = (event) => onMouseMove(event);
-  const handleMouseDown = (event) => onMouseDown(event);
-  const handleMouseUp = () => onMouseUp();
+  const handlePointerMove = (event) => onPointerMove(event);
+  const handlePointerDown = (event) => onPointerDown(event);
+  const handlePointerUp = (event) => onPointerUp(event);
  const handleMouseLeave = () => onMouseLeave();
  const handleClick = (event) => onClick(event);
  const handlePageHide = () => destroy();
  const handleRotationMode = (event) => handleRotationModeChange(event);
+  const handleInfoCardDrag = () => repositionCruiseConnector();

  bindListener(window, "resize", handleResize);
  bindListener(window, "pagehide", handlePageHide);
  bindListener(window, "beforeunload", handlePageHide);
  bindListener(window, "earth:rotation-mode-change", handleRotationMode);
-  bindListener(window, "mousemove", handleMouseMove);
-  bindListener(renderer.domElement, "mousedown", handleMouseDown);
-  bindListener(window, "mouseup", handleMouseUp);
+  bindListener(window, "earth:info-card-drag", handleInfoCardDrag);
+  bindListener(renderer.domElement, "pointerdown", handlePointerDown);
+  bindListener(window, "pointermove", handlePointerMove);
+  bindListener(window, "pointerup", handlePointerUp);
+  bindListener(window, "pointercancel", handlePointerUp);
  bindListener(renderer.domElement, "mouseleave", handleMouseLeave);
  bindListener(renderer.domElement, "click", handleClick);
+  if (renderer?.domElement) {
+    renderer.domElement.style.touchAction = "none";
+  }
 }

 function updateHudScale() {
@@ -2056,6 +2237,25 @@ function getFrontFacingBGPMarkers(markers) {
  });
 }

+function getFrontFacingComputeCenterMarkers(markers) {
+  const earth = getEarth();
+  if (!earth) return markers;
+
+  scratchCameraToEarth.subVectors(camera.position, earth.position).normalize();
+
+  return markers.filter((marker) => {
+    scratchComputeCenterWorldPosition.copy(marker.position);
+    marker.parent?.localToWorld(scratchComputeCenterWorldPosition);
+    scratchComputeCenterDirection
+      .subVectors(scratchComputeCenterWorldPosition, earth.position)
+      .normalize();
+    return (
+      scratchCameraToEarth.dot(scratchComputeCenterDirection) >
+      SATELLITE_CONFIG.frontFacingDotThreshold
+    );
+  });
+}
+
 function onMouseMove(event) {
  const earth = getEarth();
  if (!earth) return;
@@ -2078,6 +2278,9 @@ function onMouseMove(event) {
    if (Date.now() - dragStartTime > 500) {
      isLongDrag = true;
    }
+    if (pointerDragDistance > DRAG_POINTER_THRESHOLD_PX) {
+      isLongDrag = true;
+    }

    const deltaX = event.clientX - previousMousePosition.x;
    const deltaY = event.clientY - previousMousePosition.y;
@@ -2110,6 +2313,12 @@ function onMouseMove(event) {
  const bgpCollectorIntersects = getShowBGP()
    ? interactionRaycaster.intersectObjects(frontFacingBGPCollectorMarkers)
    : [];
+  const frontFacingComputeCenterMarkers = getFrontFacingComputeCenterMarkers(
+    getComputeCenterMarkers(),
+  );
+  const computeCenterIntersects = getShowComputeCenters()
+    ? interactionRaycaster.intersectObjects(frontFacingComputeCenterMarkers)
+    : [];

  let hoveredSat = null;
  let hoveredSatIndexFromIntersect = null;
@@ -2136,6 +2345,16 @@ function onMouseMove(event) {
    clearTransientHoverState();
  }

+  const hoveredComputeCenterMarker =
+    computeCenterIntersects.length > 0 ? computeCenterIntersects[0].object : null;
+
+  if (
+    hoveredComputeCenter &&
+    !isSameComputeCenter(hoveredComputeCenter, hoveredComputeCenterMarker)
+  ) {
+    clearTransientHoverState();
+  }
+
  if (
    hoveredCable &&
    (!cableIntersects.length ||
@@ -2166,6 +2385,18 @@ function onMouseMove(event) {
      showTooltip(event.clientX + TOOLTIP_CURSOR_OFFSET, event.clientY + TOOLTIP_CURSOR_OFFSET, getBGPCollectorBriefHtml(hoveredBGPMarker));
    }
    objectTooltipShown = true;
+  } else if (
+    hoveredComputeCenterMarker &&
+    getShowComputeCenters() &&
+    lockedObjectType !== "compute_center"
+  ) {
+    applyComputeCenterHoverState(hoveredComputeCenterMarker);
+    showTooltip(
+      event.clientX + TOOLTIP_CURSOR_OFFSET,
+      event.clientY + TOOLTIP_CURSOR_OFFSET,
+      getComputeCenterBriefHtml(hoveredComputeCenterMarker),
+    );
+    objectTooltipShown = true;
  } else if (cableIntersects.length > 0 && getShowCables()) {
    const cable = cableIntersects[0].object;
    hoveredCable = cable;
@@ -2193,8 +2424,11 @@ function onMouseMove(event) {
    applyBGPHoverState(lockedObject);
  } else if (lockedObjectType === "bgp_collector" && lockedObject) {
    applyBGPHoverState(lockedObject);
+  } else if (lockedObjectType === "compute_center" && lockedObject) {
+    applyComputeCenterHoverState(lockedObject);
  } else if (!lockedObjectType && !isCruisePresentationPinned()) {
    resetTransientBGPStates();
+    resetTransientComputeCenterStates();
    hideInfoCard();
  }

@@ -2245,15 +2479,121 @@ function onMouseDown(event) {
      y: earth.rotation.y,
    };
  }
+  clearDocumentSelection();
+  setGlobeDraggingUiState(true);
  document.getElementById("container")?.classList.add("dragging");
  hideTooltip();
 }

 function onMouseUp() {
  isDragging = false;
+  setGlobeDraggingUiState(false);
+  clearDocumentSelection();
  document.getElementById("container")?.classList.remove("dragging");
 }

+function onPointerDown(event) {
+  if (isEventOnHud(event)) return;
+  if (event.pointerType !== "touch" && event.button !== 0) return;
+
+  renderer?.domElement?.setPointerCapture?.(event.pointerId);
+  clearDocumentSelection();
+
+  if (event.pointerType === "touch") {
+    activeTouchPoints.set(event.pointerId, {
+      clientX: event.clientX,
+      clientY: event.clientY,
+    });
+    renderer?.domElement?.setPointerCapture?.(event.pointerId);
+
+    if (activeTouchPoints.size === 2) {
+      const [firstPoint, secondPoint] = Array.from(activeTouchPoints.values());
+      pinchGesture = {
+        distance: getTouchDistance(firstPoint, secondPoint),
+        startZoom: getZoomLevel(),
+      };
+      activeDragPointerId = null;
+      onMouseUp();
+      return;
+    }
+  }
+
+  activeDragPointerId = event.pointerId;
+  pointerDragDistance = 0;
+  suppressNextClick = false;
+  onMouseDown(event);
+}
+
+function onPointerMove(event) {
+  if (activeDragPointerId === event.pointerId && isDragging) {
+    clearDocumentSelection();
+  }
+
+  if (event.pointerType === "touch") {
+    if (activeTouchPoints.has(event.pointerId)) {
+      activeTouchPoints.set(event.pointerId, {
+        clientX: event.clientX,
+        clientY: event.clientY,
+      });
+    }
+
+    if (pinchGesture && activeTouchPoints.size >= 2) {
+      const [firstPoint, secondPoint] = Array.from(activeTouchPoints.values());
+      const nextDistance = getTouchDistance(firstPoint, secondPoint);
+      if (pinchGesture.distance > 0) {
+        const scale = nextDistance / pinchGesture.distance;
+        setZoomLevel(pinchGesture.startZoom * scale, camera);
+        suppressNextClick = true;
+        hideTooltip();
+      }
+      return;
+    }
+
+    if (activeDragPointerId === event.pointerId && isDragging) {
+      const deltaX = event.clientX - previousMousePosition.x;
+      const deltaY = event.clientY - previousMousePosition.y;
+      pointerDragDistance = Math.max(
+        pointerDragDistance,
+        Math.hypot(deltaX, deltaY),
+      );
+      onMouseMove(event);
+      return;
+    }
+
+    return;
+  }
+
+  if (activeDragPointerId === event.pointerId && isDragging) {
+    const deltaX = event.clientX - previousMousePosition.x;
+    const deltaY = event.clientY - previousMousePosition.y;
+    pointerDragDistance = Math.max(
+      pointerDragDistance,
+      Math.hypot(deltaX, deltaY),
+    );
+  }
+  onMouseMove(event);
+}
+
+function onPointerUp(event) {
+  if (event.pointerType === "touch") {
+    activeTouchPoints.delete(event.pointerId);
+    if (activeTouchPoints.size < 2) {
+      pinchGesture = null;
+    }
+  }
+
+  if (activeDragPointerId === event.pointerId) {
+    if (pointerDragDistance > DRAG_POINTER_THRESHOLD_PX) {
+      suppressNextClick = true;
+      isLongDrag = true;
+    }
+    renderer?.domElement?.releasePointerCapture?.(event.pointerId);
+    activeDragPointerId = null;
+    pointerDragDistance = 0;
+    onMouseUp();
+  }
+}
+
 function onMouseLeave() {
  hideTooltip();
 }
@@ -2262,6 +2602,10 @@ function onClick(event) {
  const earth = getEarth();
  if (!earth) return;
  if (isEventOnHud(event)) return;
+  if (suppressNextClick) {
+    suppressNextClick = false;
+    return;
+  }

  updatePointerFromEvent(event);

@@ -2280,6 +2624,11 @@ function onClick(event) {
  const bgpCollectorIntersects = getShowBGP()
    ? interactionRaycaster.intersectObjects(frontFacingBGPCollectorMarkers)
    : [];
+  const computeCenterIntersects = getShowComputeCenters()
+    ? interactionRaycaster.intersectObjects(
+        getFrontFacingComputeCenterMarkers(getComputeCenterMarkers()),
+      )
+    : [];
  const satIntersects = getShowSatellites()
    ? interactionRaycaster.intersectObject(getSatellitePoints())
    : [];
@@ -2287,6 +2636,9 @@ function onClick(event) {
  const clickedBGPMarker = getShowBGP()
    ? getPrimaryBGPClickTarget(event, bgpAnomalyIntersects, bgpCollectorIntersects)
    : null;
+  const clickedComputeCenterMarker = computeCenterIntersects.length > 0
+    ? computeCenterIntersects[0].object
+    : null;

  if (clickedBGPMarker?.userData?.type === "bgp") {
    interruptCruisePresentation();
@@ -2337,6 +2689,23 @@ function onClick(event) {
    return;
  }

+  if (clickedComputeCenterMarker?.userData?.type === "compute_center") {
+    interruptCruisePresentation();
+    clearLockedObject();
+
+    const clickedMarker = clickedComputeCenterMarker;
+    setComputeCenterMarkerState(clickedMarker, "locked");
+    lockedObject = clickedMarker;
+    lockedObjectType = "compute_center";
+    setAutoRotate(false);
+    showComputeCenterInfo(clickedMarker, { x: event.clientX, y: event.clientY });
+    showStatusMessage(
+      `已选择算力中心: ${clickedMarker.userData?.name || "未知节点"}`,
+      "info",
+    );
+    return;
+  }
+
  if (cableIntersects.length > 0 && getShowCables()) {
    interruptCruisePresentation();
    clearLockedObject();
@@ -2494,6 +2863,7 @@ function animate() {
      ? cruiseSequencer?.getCurrentItem() ?? null
      : null;
  updateBGPVisualState(lockedObjectType, lockedObject, camera, activeCruiseMarker);
+  updateComputeCenterVisualState(lockedObjectType, lockedObject, camera);

  if (lockedObjectType === "cable" && lockedObject) {
    applyLandingPointVisualState(lockedObject.userData.name, false, camera);
@@ -2541,6 +2911,8 @@ export function destroy() {
  destroyed = true;
  currentLoadToken += 1;
  isDataLoading = false;
+  setGlobeDraggingUiState(false);
+  clearDocumentSelection();

  if (animationFrameId) {
    cancelAnimationFrame(animationFrameId);
@@ -2556,6 +2928,7 @@ export function destroy() {
  clearLockedObject();
  clearCableData(getEarth());
  clearBGPData(getEarth());
+  clearComputeCenterData(getEarth());
  resetSatelliteState();
  clearUiState();
  disposeCelestialLayer();
--- a/frontend/public/earth/js/news.js
+++ b/frontend/public/earth/js/news.js
@@ -18,17 +18,18 @@ let lastFocus = null;
 let lastFetchAt = 0;
 let lastRegionSwitchAt = 0;
 function getElements() {
+  const isMobile = document.body.classList.contains("layout-mode-mobile");
  return {
-    refreshBtn: document.getElementById("news-refresh"),
-    openBtn: document.getElementById("news-open-external"),
-    status: document.getElementById("news-board-status"),
-    focusLabel: document.getElementById("news-focus-label"),
-    focusCoords: document.getElementById("news-focus-coords"),
-    sourceCount: document.getElementById("news-source-count"),
+    refreshBtn: document.getElementById(isMobile ? "mobile-news-refresh" : "news-refresh"),
+    openBtn: document.getElementById(isMobile ? "mobile-news-open-external" : "news-open-external"),
+    status: document.getElementById(isMobile ? "mobile-news-board-status" : "news-board-status"),
+    focusLabel: document.getElementById(isMobile ? "mobile-news-focus-label" : "news-focus-label"),
+    focusCoords: document.getElementById(isMobile ? "mobile-news-focus-coords" : "news-focus-coords"),
+    sourceCount: document.getElementById(isMobile ? "mobile-news-source-count" : "news-source-count"),
    regionChip: document.getElementById("news-region-chip"),
-    board: document.getElementById("news-board-list"),
-    empty: document.getElementById("news-board-empty"),
-    feedAnchor: document.getElementById("news-feed-anchor"),
+    board: document.getElementById(isMobile ? "mobile-news-board-list" : "news-board-list"),
+    empty: document.getElementById(isMobile ? "mobile-news-board-empty" : "news-board-empty"),
+    feedAnchor: document.getElementById(isMobile ? "mobile-news-feed-anchor" : "news-feed-anchor"),
  };
 }

@@ -81,18 +82,33 @@ function renderPayload(nextPayload) {
    openBtn,
    feedAnchor,
  } = getElements();
-
-  if (!board || !status || !focusLabel || !focusCoords || !sourceCount || !regionChip) {
-    return;
-  }
-
  const items = Array.isArray(nextPayload?.items) ? nextPayload.items : [];
  const sources = Array.isArray(nextPayload?.sources) ? nextPayload.sources : [];
  const focus = nextPayload?.focus || {};

+  if (!board || !status || !focusLabel || !focusCoords || !sourceCount || !regionChip) {
+    if (document.body.classList.contains("layout-mode-mobile")) {
+      // Mobile page omits the region chip shell, but the rest of the page is still renderable.
+      if (!board || !status || !focusLabel || !focusCoords || !sourceCount) {
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+
+  if (regionChip) {
+    regionChip.textContent = focus.region || "global";
+    regionChip.style.setProperty("--news-accent", focus.accent || "#d6e6ff");
+  }
+
+  if (document.body.classList.contains("layout-mode-mobile")) {
+    // Mobile page does not show the compact chip row.
+  } else if (!regionChip) {
+    return;
+  }
+
  focusLabel.textContent = focus.label || "全球焦点";
-  regionChip.textContent = focus.region || "global";
-  regionChip.style.setProperty("--news-accent", focus.accent || "#d6e6ff");

  if (typeof focus.lat === "number" && typeof focus.lon === "number") {
    focusCoords.textContent = `${formatCoord(focus.lat, "N", "S")} · ${formatCoord(focus.lon, "E", "W")}`;
@@ -275,8 +291,6 @@ export function initNewsPanel() {
  if (initialized) return;
  initialized = true;

-  const { refreshBtn, openBtn } = getElements();
-
  updateNewsToggleUI(isTVPanelVisible());
  renderEmptyState("正在准备全球态势新闻聚合源...");

@@ -287,16 +301,22 @@ export function initNewsPanel() {
    updateNewsToggleUI(Boolean(event.detail?.visible));
  });

-  refreshBtn?.addEventListener("click", async () => {
-    try {
-      await refreshNews(lastFocus?.lat, lastFocus?.lon);
-      showStatusMessage("态势新闻已刷新", "info");
-    } catch {
-      showStatusMessage("态势新闻刷新失败", "error");
-    }
+  ["news-refresh", "mobile-news-refresh"].forEach((id) => {
+    const refreshBtn = document.getElementById(id);
+    refreshBtn?.addEventListener("click", async () => {
+      try {
+        await refreshNews(lastFocus?.lat, lastFocus?.lon);
+        showStatusMessage("态势新闻已刷新", "info");
+      } catch {
+        showStatusMessage("态势新闻刷新失败", "error");
+      }
+    });
  });

-  openBtn?.addEventListener("click", openCurrentSourceHomepage);
+  ["news-open-external", "mobile-news-open-external"].forEach((id) => {
+    const openBtn = document.getElementById(id);
+    openBtn?.addEventListener("click", openCurrentSourceHomepage);
+  });

  refreshNews(undefined, undefined, { silent: true }).catch(() => {});
 }
--- a/frontend/public/earth/js/search.js
+++ b/frontend/public/earth/js/search.js
@@ -4,6 +4,7 @@ let onSelectResultFn = null;
 let currentResults = [];
 let activeIndex = -1;
 let searchTimerId = null;
+let isOpen = false;

 function escapeHtml(value) {
  return String(value)
@@ -15,14 +16,25 @@ function escapeHtml(value) {
 }

 function getElements() {
+  const isMobile = document.body.classList.contains("layout-mode-mobile");
  return {
    modal: document.getElementById("search-modal"),
    backdrop: document.getElementById("search-backdrop"),
-    input: document.getElementById("earth-search-input"),
-    clear: document.getElementById("earth-search-clear"),
-    meta: document.getElementById("earth-search-meta"),
-    results: document.getElementById("earth-search-results"),
-    empty: document.getElementById("earth-search-empty"),
+    input: document.getElementById(
+      isMobile ? "mobile-earth-search-input" : "earth-search-input",
+    ),
+    clear: document.getElementById(
+      isMobile ? "mobile-earth-search-clear" : "earth-search-clear",
+    ),
+    meta: document.getElementById(
+      isMobile ? "mobile-earth-search-meta" : "earth-search-meta",
+    ),
+    results: document.getElementById(
+      isMobile ? "mobile-earth-search-results" : "earth-search-results",
+    ),
+    empty: document.getElementById(
+      isMobile ? "mobile-earth-search-empty" : "earth-search-empty",
+    ),
    close: document.getElementById("search-close"),
  };
 }
@@ -36,7 +48,7 @@ function updateEmptyState(query) {
  const { empty } = getElements();
  if (!empty) return;
  if (!query) {
-    empty.textContent = "支持搜索海缆、登陆点、卫星、BGP 事件与观测站。";
+    empty.textContent = "支持搜索海缆、登陆点、卫星、算力中心、BGP 事件与观测站。";
    return;
  }
  empty.textContent = "未找到匹配对象，可尝试名称、地点、NORAD、ASN、前缀等关键词。";
@@ -154,7 +166,8 @@ function scheduleSearch() {

 function handleKeydown(event) {
  const { modal, input } = getElements();
-  if (!modal?.classList.contains("is-open")) return;
+  const isMobile = document.body.classList.contains("layout-mode-mobile");
+  if (!isMobile && !modal?.classList.contains("is-open")) return;

  if (event.key === "Escape") {
    event.preventDefault();
@@ -185,15 +198,28 @@ export function initSearchPanel({ resolveResults, onSelectResult } = {}) {
  if (initialized) return;
  initialized = true;

-  const { input, clear, close, backdrop } = getElements();
-  input?.addEventListener("input", scheduleSearch);
-  input?.addEventListener("keydown", handleKeydown);
-  clear?.addEventListener("click", () => {
-    if (!input) return;
-    input.value = "";
-    input.focus();
-    runSearch().catch((error) => {
-      console.warn("Clearing search failed:", error);
+  const inputs = ["earth-search-input", "mobile-earth-search-input"]
+    .map((id) => document.getElementById(id))
+    .filter((node) => node instanceof HTMLInputElement);
+  const clears = ["earth-search-clear", "mobile-earth-search-clear"]
+    .map((id) => document.getElementById(id))
+    .filter((node) => node instanceof HTMLButtonElement);
+  const close = document.getElementById("search-close");
+  const backdrop = document.getElementById("search-backdrop");
+
+  inputs.forEach((input) => {
+    input.addEventListener("input", scheduleSearch);
+    input.addEventListener("keydown", handleKeydown);
+  });
+  clears.forEach((clear) => {
+    clear.addEventListener("click", () => {
+      const { input } = getElements();
+      if (!input) return;
+      input.value = "";
+      input.focus();
+      runSearch().catch((error) => {
+        console.warn("Clearing search failed:", error);
+      });
    });
  });
  close?.addEventListener("click", () => {
@@ -207,9 +233,15 @@ export function initSearchPanel({ resolveResults, onSelectResult } = {}) {

 export function openSearchPanel() {
  const { modal, input } = getElements();
-  if (!modal) return;
-  modal.classList.add("is-open");
-  modal.setAttribute("aria-hidden", "false");
+  if (!modal && !document.body.classList.contains("layout-mode-mobile")) return;
+  if (isOpen) return;
+  isOpen = true;
+  document.body.classList.add("earth-search-open");
+  modal?.classList.add("is-open");
+  modal?.setAttribute("aria-hidden", "false");
+  window.dispatchEvent(
+    new CustomEvent("earth:search-open-change", { detail: { open: true } }),
+  );
  window.setTimeout(() => {
    input?.focus();
    input?.select();
@@ -219,9 +251,32 @@ export function openSearchPanel() {
  }, 16);
 }

+export function focusSearchInput({ select = false } = {}) {
+  const { input } = getElements();
+  if (!(input instanceof HTMLInputElement)) return;
+  input.focus();
+  if (select) {
+    input.select();
+  }
+}
+
+export function refreshSearchResults() {
+  return runSearch();
+}
+
 export function closeSearchPanel() {
  const { modal } = getElements();
-  if (!modal) return;
-  modal.classList.remove("is-open");
-  modal.setAttribute("aria-hidden", "true");
+  if (!modal && !document.body.classList.contains("layout-mode-mobile")) return;
+  if (!isOpen) return;
+  isOpen = false;
+  document.body.classList.remove("earth-search-open");
+  modal?.classList.remove("is-open");
+  modal?.setAttribute("aria-hidden", "true");
+  window.dispatchEvent(
+    new CustomEvent("earth:search-open-change", { detail: { open: false } }),
+  );
+}
+
+export function isSearchPanelOpen() {
+  return isOpen;
 }
--- a/frontend/public/earth/js/tv.js
+++ b/frontend/public/earth/js/tv.js
@@ -56,21 +56,22 @@ const HLS_RETRY_CONFIG = {
 };

 function getElements() {
+  const isMobile = document.body.classList.contains("layout-mode-mobile");
  return {
    // Outer media shell node.
    panel: document.getElementById("media-panel"),
    toggleBtn: document.getElementById("toggle-tv"),
-    select: document.getElementById("tv-source-select"),
-    title: document.getElementById("tv-source-title"),
-    meta: document.getElementById("tv-source-meta"),
-    catalog: document.getElementById("tv-source-catalog"),
-    status: document.getElementById("tv-source-status"),
-    notes: document.getElementById("tv-source-notes"),
-    iframe: document.getElementById("tv-iframe"),
-    video: document.getElementById("tv-video"),
-    empty: document.getElementById("tv-empty-state"),
-    refreshBtn: document.getElementById("tv-refresh"),
-    openBtn: document.getElementById("tv-open-external"),
+    select: document.getElementById(isMobile ? "mobile-tv-source-select" : "tv-source-select"),
+    title: document.getElementById(isMobile ? "mobile-tv-source-title" : "tv-source-title"),
+    meta: document.getElementById(isMobile ? "mobile-tv-source-meta" : "tv-source-meta"),
+    catalog: document.getElementById(isMobile ? "mobile-tv-source-catalog" : "tv-source-catalog"),
+    status: document.getElementById(isMobile ? "mobile-tv-source-status" : "tv-source-status"),
+    notes: document.getElementById(isMobile ? "mobile-tv-source-notes" : "tv-source-notes"),
+    iframe: document.getElementById(isMobile ? "mobile-tv-iframe" : "tv-iframe"),
+    video: document.getElementById(isMobile ? "mobile-tv-video" : "tv-video"),
+    empty: document.getElementById(isMobile ? "mobile-tv-empty-state" : "tv-empty-state"),
+    refreshBtn: document.getElementById(isMobile ? "mobile-tv-refresh" : "tv-refresh"),
+    openBtn: document.getElementById(isMobile ? "mobile-tv-open-external" : "tv-open-external"),
    metaWrap: document.getElementById("tv-meta-wrap"),
    metaToggle: document.getElementById("tv-meta-toggle"),
    liveHeaderControls: document.getElementById("tv-header-controls-live"),
@@ -351,6 +352,7 @@ function setPanelVisible(visible) {
  const { panel } = getElements();
  if (!panel) return;
  mediaPanel?.setVisible(visible);
+  document.body.classList.toggle("earth-media-open", visible);
  updateToggleButton(visible);
  syncSettingsToggle(visible);
  window.dispatchEvent(new CustomEvent("earth:tv-visibility-change", {
@@ -1071,12 +1073,16 @@ export function initTVPanel() {
    showStatusMessage("已切换到态势新闻", "info");
  });

-  select?.addEventListener("change", (event) => {
-    const target = event.currentTarget;
-    if (!(target instanceof HTMLSelectElement)) return;
-    currentSourceId = target.value;
-    renderSource(findSourceById(currentSourceId));
-  });
+  [select, document.getElementById("mobile-tv-source-select"), document.getElementById("tv-source-select")]
+    .filter((element, index, array) => element && array.indexOf(element) === index)
+    .forEach((selectEl) => {
+      selectEl?.addEventListener("change", (event) => {
+        const target = event.currentTarget;
+        if (!(target instanceof HTMLSelectElement)) return;
+        currentSourceId = target.value;
+        renderSource(findSourceById(currentSourceId));
+      });
+    });

  metaToggle?.addEventListener("click", () => {
    clearTimeout(metaAutoCollapseTimer);
@@ -1084,9 +1090,13 @@ export function initTVPanel() {
    setMetaCollapsed(isNowCollapsed);
  });

-  refreshBtn?.addEventListener("click", () => {
-    refreshTVPanel();
-  });
+  [refreshBtn, document.getElementById("mobile-tv-refresh"), document.getElementById("tv-refresh")]
+    .filter((element, index, array) => element && array.indexOf(element) === index)
+    .forEach((refreshEl) => {
+      refreshEl?.addEventListener("click", () => {
+        refreshTVPanel();
+      });
+    });

  liveTabBtn?.addEventListener("click", () => {
    setActiveTab("live");
@@ -1095,24 +1105,32 @@ export function initTVPanel() {
    setActiveTab("news");
  });

-  iframe?.addEventListener("load", () => {
-    if (iframe.hidden) return;
-    clearSourceFailed(currentSourceId);
-    setPanelMessage(TV_STATUS_MESSAGE.iframeReady);
-  });
+  [iframe, document.getElementById("mobile-tv-iframe"), document.getElementById("tv-iframe")]
+    .filter((element, index, array) => element && array.indexOf(element) === index)
+    .forEach((iframeEl) => {
+      iframeEl?.addEventListener("load", () => {
+        if (iframeEl.hidden) return;
+        clearSourceFailed(currentSourceId);
+        setPanelMessage(TV_STATUS_MESSAGE.iframeReady);
+      });
+    });

-  video?.addEventListener("loadedmetadata", () => {
-    if (video.hidden) return;
-    clearSourceFailed(currentSourceId);
-    setPanelMessage(TV_STATUS_MESSAGE.videoReady);
-  });
+  [video, document.getElementById("mobile-tv-video"), document.getElementById("tv-video")]
+    .filter((element, index, array) => element && array.indexOf(element) === index)
+    .forEach((videoEl) => {
+      videoEl?.addEventListener("loadedmetadata", () => {
+        if (videoEl.hidden) return;
+        clearSourceFailed(currentSourceId);
+        setPanelMessage(TV_STATUS_MESSAGE.videoReady);
+      });

-  video?.addEventListener("error", () => {
-    const currentSource = getCurrentSource();
-    if (!showEmbeddedFallback(currentSource) && !tryFallbackSource()) {
-      setPanelMessage(TV_STATUS_MESSAGE.videoError);
-    }
-  });
+      videoEl?.addEventListener("error", () => {
+        const currentSource = getCurrentSource();
+        if (!showEmbeddedFallback(currentSource) && !tryFallbackSource()) {
+          setPanelMessage(TV_STATUS_MESSAGE.videoError);
+        }
+      });
+    });

  setupResizeHandle();
  syncPanelActiveTab("live");
--- a/frontend/public/earth/js/ui.js
+++ b/frontend/public/earth/js/ui.js
@@ -19,6 +19,20 @@ function getElement(id) {
  return document.getElementById(id);
 }

+function getEarthStatTargets(statKey) {
+  return Array.from(
+    document.querySelectorAll(`[data-earth-stat="${statKey}"]`),
+  );
+}
+
+export function setEarthStatValue(statKey, value) {
+  getEarthStatTargets(statKey).forEach((element) => {
+    if (element instanceof HTMLElement) {
+      element.textContent = value;
+    }
+  });
+}
+
 function setElementDisplay(element, visible, displayValue = "block") {
  if (!element) return;
  element.style.display = visible ? displayValue : "none";
@@ -171,27 +185,14 @@ export function updateZoomDisplay(zoomLevel, distance) {

 // Update earth stats
 export function updateEarthStats(stats) {
-  const cableCountEl = getElement("cable-count");
-  const landingPointCountEl = getElement("landing-point-count");
-  const bgpAnomalyCountEl = getElement("bgp-anomaly-count");
-  const bgpCollectorCountEl = getElement("bgp-collector-count");
-  const bgpStatusSummaryEl = getElement("bgp-status-summary");
-  const terrainStatusEl = getElement("terrain-status");
-  const textureQualityEl = getElement("texture-quality");
-
-  if (cableCountEl) cableCountEl.textContent = stats.cableCount || 0;
-  if (landingPointCountEl)
-    landingPointCountEl.textContent = stats.landingPointCount || 0;
-  if (bgpAnomalyCountEl)
-    bgpAnomalyCountEl.textContent = stats.bgpAnomalyCount || 0;
-  if (bgpCollectorCountEl)
-    bgpCollectorCountEl.textContent = stats.bgpCollectorCount || 0;
-  if (bgpStatusSummaryEl)
-    bgpStatusSummaryEl.textContent = stats.bgpStatusSummary || "-";
-  if (terrainStatusEl)
-    terrainStatusEl.textContent = stats.terrainOn ? "开启" : "关闭";
-  if (textureQualityEl)
-    textureQualityEl.textContent = stats.textureQuality || "8K 卫星图";
+  setEarthStatValue("cable-count", String(stats.cableCount || 0));
+  setEarthStatValue("landing-point-count", String(stats.landingPointCount || 0));
+  setEarthStatValue("compute-center-count", String(stats.computeCenterCount || 0));
+  setEarthStatValue("bgp-anomaly-count", String(stats.bgpAnomalyCount || 0));
+  setEarthStatValue("bgp-collector-count", String(stats.bgpCollectorCount || 0));
+  setEarthStatValue("bgp-status-summary", stats.bgpStatusSummary || "-");
+  setEarthStatValue("terrain-status", stats.terrainOn ? "开启" : "关闭");
+  setEarthStatValue("texture-quality", stats.textureQuality || "8K 卫星图");
 }

 // Show/hide loading via status message
--- a/frontend/public/earth/js/utils.js
+++ b/frontend/public/earth/js/utils.js
@@ -4,6 +4,10 @@ import * as THREE from "three";

 import { CONFIG } from "./constants.js";

+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
 // Convert latitude/longitude to 3D vector
 export function latLonToVector3(lat, lon, radius = CONFIG.earthRadius) {
  const phi = (90 - lat) * (Math.PI / 180);
@@ -90,3 +94,31 @@ export function calculateDistance(

  return radius * c;
 }
+
+export function getSurfaceMarkerCameraScale(camera, options = {}) {
+  if (!camera) return 1;
+
+  const {
+    altitudeOffset = 0,
+    referenceFov = 75,
+    min = 0.12,
+    max = 3.0,
+  } = options;
+
+  const cameraDistanceFromCenter = camera.position.length();
+  const surfaceDistance = Math.max(
+    1,
+    cameraDistanceFromCenter - (CONFIG.earthRadius + altitudeOffset),
+  );
+  const referenceSurfaceDistance = Math.max(
+    1,
+    CONFIG.defaultCameraZ - (CONFIG.earthRadius + altitudeOffset),
+  );
+  const cameraFovRad = (((camera.fov || referenceFov)) * Math.PI) / 180;
+  const referenceFovRad = (referenceFov * Math.PI) / 180;
+  const worldPerPixel = surfaceDistance * Math.tan(cameraFovRad / 2);
+  const referenceWorldPerPixel =
+    referenceSurfaceDistance * Math.tan(referenceFovRad / 2);
+
+  return clamp(worldPerPixel / referenceWorldPerPixel, min, max);
+}
--- a/planet.sh
+++ b/planet.sh
@@ -520,12 +520,13 @@ print_database_failure_diagnostics() {
 compute_ai_provider_build_fingerprint() {
    (
        cd "$SCRIPT_DIR" || exit 1
-        tar -cf - \
-            aiprovider \
-            pyproject.toml \
-            uv.lock \
-            docker-compose.yml \
-            docker-compose.simple.yml 2>/dev/null
+        {
+            tar -cf - \
+                aiprovider \
+                docker-compose.yml \
+                docker-compose.simple.yml 2>/dev/null
+            python3 "$SCRIPT_DIR/scripts/compute_aiprovider_dependency_fingerprint.py"
+        }
    ) | sha256sum | awk '{print $1}'
 }

--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "planet"
-version = "0.34.0"
+version = "0.37.0"
 description = "智能星球计划 - 态势感知系统"
 requires-python = ">=3.14"
 dependencies = [
--- a/scripts/compute_aiprovider_dependency_fingerprint.py
+++ b/scripts/compute_aiprovider_dependency_fingerprint.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+
+IMPORT_TO_DISTRIBUTION = {
+    "pydantic_settings": "pydantic-settings",
+}
+
+# Some runtime dependencies are referenced indirectly:
+# - uvicorn is launched by the container command rather than imported.
+# - python-dotenv is used by pydantic-settings when loading the local .env file.
+EXTRA_RUNTIME_DISTRIBUTIONS = {
+    "python-dotenv",
+    "uvicorn",
+}
+
+
+def normalize_name(value: str) -> str:
+    return value.strip().lower().replace("_", "-").replace(".", "-")
+
+
+def extract_table(text: str, table_name: str) -> str:
+    pattern = re.compile(
+        rf"(?ms)^\[{re.escape(table_name)}\]\s*$\n(.*?)(?=^\[[^\]]+\]\s*$|\Z)"
+    )
+    match = pattern.search(text)
+    return match.group(1) if match else ""
+
+
+def extract_string_value(text: str, key: str) -> str | None:
+    match = re.search(rf'(?m)^{re.escape(key)}\s*=\s*"([^"]+)"\s*$', text)
+    return match.group(1) if match else None
+
+
+def extract_string_list_value(text: str, key: str) -> list[str]:
+    match = re.search(rf"(?ms)^{re.escape(key)}\s*=\s*\[(.*?)\]\s*$", text)
+    if not match:
+        return []
+    return re.findall(r'"([^"]+)"', match.group(1))
+
+
+def project_dependency_map(pyproject_text: str) -> tuple[str | None, dict[str, str]]:
+    project_block = extract_table(pyproject_text, "project")
+    requires_python = extract_string_value(project_block, "requires-python")
+    dependencies = extract_string_list_value(project_block, "dependencies")
+    mapping: dict[str, str] = {}
+    for spec in dependencies:
+        name = spec.split(";", 1)[0].strip()
+        for marker in ("<", ">", "=", "!", "~"):
+            if marker in name:
+                name = name.split(marker, 1)[0].strip()
+        if "[" in name:
+            name = name.split("[", 1)[0].strip()
+        mapping[normalize_name(name)] = spec.strip()
+    return requires_python, mapping
+
+
+def collect_runtime_imports(aiprovider_dir: Path) -> set[str]:
+    imports: set[str] = set()
+    stdlib = set(sys.stdlib_module_names)
+
+    for path in sorted(aiprovider_dir.rglob("*.py")):
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.add(alias.name.split(".", 1)[0])
+            elif isinstance(node, ast.ImportFrom) and node.module:
+                imports.add(node.module.split(".", 1)[0])
+
+    return {
+        name
+        for name in imports
+        if name not in stdlib and name != "aiprovider"
+    }
+
+
+def resolve_relevant_root_dependencies(
+    pyproject_deps: dict[str, str],
+    imported_modules: set[str],
+) -> dict[str, str]:
+    relevant_names: set[str] = set(EXTRA_RUNTIME_DISTRIBUTIONS)
+
+    for module_name in imported_modules:
+        mapped_name = IMPORT_TO_DISTRIBUTION.get(module_name, module_name)
+        normalized_name = normalize_name(mapped_name)
+        if normalized_name in pyproject_deps:
+            relevant_names.add(normalized_name)
+
+    return {
+        name: pyproject_deps[name]
+        for name in sorted(relevant_names)
+        if name in pyproject_deps
+    }
+
+
+def lock_metadata(lock_text: str) -> dict[str, str | None]:
+    return {
+        "version": extract_string_value(lock_text, "version") or re.search(r"(?m)^version\s*=\s*(\d+)\s*$", lock_text).group(1),
+        "revision": extract_string_value(lock_text, "revision") or re.search(r"(?m)^revision\s*=\s*(\d+)\s*$", lock_text).group(1),
+        "requires_python": extract_string_value(lock_text, "requires-python"),
+    }
+
+
+def lock_package_map(lock_text: str) -> dict[str, dict[str, Any]]:
+    mapping: dict[str, dict[str, Any]] = {}
+    sections = re.split(r"(?m)^\[\[package\]\]\s*$\n?", lock_text)
+    for section in sections[1:]:
+        raw_section = section.strip()
+        name = extract_string_value(raw_section, "name")
+        if not name:
+            continue
+        version = extract_string_value(raw_section, "version")
+        dependency_names = [
+            normalize_name(dep_name)
+            for dep_name in re.findall(r'\{\s*name\s*=\s*"([^"]+)"', raw_section)
+        ]
+        mapping[normalize_name(name)] = {
+            "name": name,
+            "version": version,
+            "dependencies": dependency_names,
+            "raw": raw_section,
+        }
+    return mapping
+
+
+def dependency_closure(
+    lock_packages: dict[str, dict[str, Any]],
+    root_dependencies: dict[str, str],
+) -> list[dict[str, Any]]:
+    pending = list(root_dependencies.keys())
+    visited: set[str] = set()
+    resolved: list[dict[str, Any]] = []
+
+    while pending:
+        current = pending.pop()
+        if current in visited:
+            continue
+        visited.add(current)
+
+        package = lock_packages.get(current)
+        if package is None:
+            continue
+
+        resolved.append(package)
+        for dep_name in package.get("dependencies", []):
+            pending.append(dep_name)
+
+    resolved.sort(key=lambda pkg: (normalize_name(pkg["name"]), pkg.get("version", "")))
+    return resolved
+
+
+def main() -> int:
+    repo_root = Path(__file__).resolve().parents[1]
+    pyproject_path = repo_root / "pyproject.toml"
+    uv_lock_path = repo_root / "uv.lock"
+    aiprovider_dir = repo_root / "aiprovider"
+
+    pyproject_text = pyproject_path.read_text(encoding="utf-8")
+    uv_lock_text = uv_lock_path.read_text(encoding="utf-8")
+
+    requires_python, pyproject_deps = project_dependency_map(pyproject_text)
+    imported_modules = collect_runtime_imports(aiprovider_dir)
+    relevant_roots = resolve_relevant_root_dependencies(pyproject_deps, imported_modules)
+    relevant_packages = dependency_closure(lock_package_map(uv_lock_text), relevant_roots)
+
+    fingerprint_payload = {
+        "requires_python": requires_python,
+        "relevant_root_dependencies": relevant_roots,
+        "lock": {**lock_metadata(uv_lock_text), "packages": relevant_packages},
+    }
+
+    print(json.dumps(fingerprint_payload, ensure_ascii=True, sort_keys=True, separators=(",", ":")))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
--- a/uv.lock
+++ b/uv.lock
@@ -475,7 +475,7 @@ wheels = [

 [[package]]
 name = "planet"
-version = "0.34.0"
+version = "0.37.0"
 source = { virtual = "." }
 dependencies = [
    { name = "aiofiles" },
Author	SHA1	Message	Date
rayd1o	67f82dc41c	release: bump version to 0.37.0	2026-04-23 07:56:10 +08:00
rayd1o	abe04030fb	release: bump version to 0.36.0	2026-04-22 23:42:10 +08:00
linkong	6a5f9f7ad4	release: bump version to 0.35.1	2026-04-22 18:04:54 +08:00
linkong	439a512148	docs: add earth mobile drawer UI plan and Claude Code/Codex toolchain - Add earth-mobile-drawer-ui-plan documenting mobile drawer UX decisions - Add goal-driven.md Claude Code command for autonomous task execution - Add .codex/ config with OpenAI model definitions and goal-driven agent - Add SKILL.md, openai.yaml, and prompt-template for Codex integration	2026-04-22 17:37:00 +08:00
linkong	f73fa1ea6d	release: bump version to 0.35.0	2026-04-22 17:29:24 +08:00
@@ -1 +1 @@
 .34.0
 .37.0