nekolas note

毎日書くことを目指しているけど全然達成できてないブログ

26.8 KB Raw
//! LSP(stdio)処理(T026/T029/T034)。
//! 参照: contracts/zed-ide-bridge.md
//!
//! Zed はこのプロセスを language server として起動する。ここでは:
//!  - initialize: capabilities 応答 + initializationOptions(portRange)を main へ通知
//!  - didOpen/didChange: アクティブファイル(FR-020)
//!  - documentHighlight: カーソル位置(FR-021, デバウンス)
//!  - codeAction: 選択範囲(FR-021, 副作用依存・デバウンス)
//!  - inlayHint/documentSymbol/documentColor/foldingRange/codeLens:
//!    タブ切替の捕捉(FR-030, レンダリング駆動シグナル・デバウンス)
//! を捕捉し、SharedState を更新する(更新時に push 配信される)。
//!
//! untitled/未保存/対象外ファイルは安全に無視(FR-023, エラーにしない)。

use crate::notify::LspOut;
use crate::protocol::{rpc_result, RpcMessage};
use crate::state::{EditorContext, Position, Selection, SharedState};
use anyhow::Result;
use serde_json::{json, Value};
use std::sync::Arc;
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
use tokio::sync::oneshot;

/// initialize 受信時に main へ渡す情報。
pub struct InitInfo {
    pub port_min: u16,
    pub port_max: u16,
}

/// LSP メインループ。stdin を読み、Content-Length フレームを解釈して dispatch する。
pub async fn run<R>(
    mut reader: R,
    out: LspOut,
    state: Arc<SharedState>,
    // initialize を受け取ったら一度だけ送る(WS サーバ起動のトリガ)。
    init_tx: oneshot::Sender<InitInfo>,
) -> Result<()>
where
    R: AsyncRead + Unpin,
{
    let mut init_tx = Some(init_tx);
    // codeAction/documentHighlight はデバウンスする(FR-025)。
    let (debounce_tx, debounce_rx) = mpsc::unbounded_channel::<EditorContext>();
    spawn_debouncer(debounce_rx, state.clone(), Duration::from_millis(80));

    // 開いているドキュメントの本文(uri -> text)。選択テキスト抽出に使う。
    let mut docs: std::collections::HashMap<String, String> = std::collections::HashMap::new();

    let mut buf: Vec<u8> = Vec::new();
    let mut chunk = [0u8; 8192];

    loop {
        // 既存バッファから 1 メッセージを取り出せるか試す。
        while let Some((headers_end, content_len)) = peek_frame(&buf) {
            let total = headers_end + content_len;
            if buf.len() < total {
                break; // body 未到着
            }
            let body = buf[headers_end..total].to_vec();
            buf.drain(0..total);
            if let Ok(msg) = serde_json::from_slice::<RpcMessage>(&body) {
                handle_message(msg, &out, &state, &debounce_tx, &mut init_tx, &mut docs).await;
            }
        }

        let n = reader.read(&mut chunk).await?;
        if n == 0 {
            break; // EOF(Zed 終了)
        }
        buf.extend_from_slice(&chunk[..n]);
    }
    Ok(())
}

/// バッファ先頭の `Content-Length` ヘッダを解析し、(ヘッダ終端, 本文長) を返す。
fn peek_frame(buf: &[u8]) -> Option<(usize, usize)> {
    let sep = b"\r\n\r\n";
    let pos = buf.windows(4).position(|w| w == sep)?;
    let headers = std::str::from_utf8(&buf[..pos]).ok()?;
    let mut len = None;
    for line in headers.split("\r\n") {
        if let Some(v) = line.strip_prefix("Content-Length:") {
            len = v.trim().parse::<usize>().ok();
        }
    }
    Some((pos + 4, len?))
}

async fn handle_message(
    msg: RpcMessage,
    out: &LspOut,
    state: &Arc<SharedState>,
    debounce_tx: &mpsc::UnboundedSender<EditorContext>,
    init_tx: &mut Option<oneshot::Sender<InitInfo>>,
    docs: &mut std::collections::HashMap<String, String>,
) {
    let method = match &msg.method {
        Some(m) => m.as_str(),
        None => return, // レスポンスは無視
    };
    trace_log(
        "recv",
        method,
        extract_uri(msg.params.as_ref()).as_deref().unwrap_or(""),
    );

    match method {
        "initialize" => {
            // initializationOptions から portRange を読む。
            let (min, max) = parse_port_range(msg.params.as_ref());
            if let Some(tx) = init_tx.take() {
                let _ = tx.send(InitInfo {
                    port_min: min,
                    port_max: max,
                });
            }
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, server_capabilities()));
            }
        }
        "initialized" | "$/setTrace" => { /* 通知: 何もしない */ }
        "shutdown" => {
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, Value::Null));
            }
        }
        "exit" => {
            std::process::exit(0);
        }
        "textDocument/didOpen" | "textDocument/didChange" => {
            // アクティブファイルを更新(FR-020)。本文も保持(選択テキスト抽出用)。
            if let Some(uri) = extract_uri(msg.params.as_ref()) {
                if let Some(text) = extract_document_text(msg.params.as_ref()) {
                    docs.insert(uri.clone(), text);
                }
                update_active_file(state, &uri).await;
            }
        }
        "textDocument/documentHighlight" => {
            // カーソル位置を選択(空)として捕捉(FR-021)。text は ""。
            if let (Some(uri), Some(pos)) = (
                extract_text_document_uri(msg.params.as_ref()),
                extract_position(msg.params.as_ref()),
            ) {
                let ctx = build_ctx(
                    &uri,
                    Selection {
                        start: pos.clone(),
                        end: pos,
                        is_empty: true,
                    },
                    String::new(),
                );
                let _ = debounce_tx.send(ctx);
            }
            // documentHighlight には結果(ハイライト範囲)を返す必要があるが、
            // 本ブリッジは副作用(位置取得)目的なので空配列で良い。
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, json!([])));
            }
        }
        "textDocument/codeAction" => {
            // codeAction の range を選択範囲として捕捉(FR-021, 副作用依存)。
            // 保持中の本文から選択テキストを抽出して text に載せる。
            if let (Some(uri), Some(sel)) = (
                extract_text_document_uri(msg.params.as_ref()),
                extract_range_as_selection(msg.params.as_ref()),
            ) {
                let text = if sel.is_empty {
                    String::new()
                } else {
                    docs.get(&uri)
                        .map(|content| extract_range_text(content, &sel))
                        .unwrap_or_default()
                };
                let ctx = build_ctx(&uri, sel, text);
                let _ = debounce_tx.send(ctx);
            }
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, json!([])));
            }
        }
        // FR-030: タブ切替の捕捉。Zed はタブ切替(アクティブエディタ変更)単体では
        // 編集系シグナル(didChange/documentHighlight 等)を発火しないが、
        // 「可視になったバッファ」へのレンダリング駆動リクエストは発行する。
        // これを契機に URI がアクティブファイルと異なればタブ切替とみなして push する。
        // エディタ操作起因のイベント駆動であり、FR-027 のハートビート禁止に該当しない。
        "textDocument/inlayHint"
        | "textDocument/documentSymbol"
        | "textDocument/documentColor"
        | "textDocument/foldingRange"
        | "textDocument/codeLens" => {
            if let Some(uri) = extract_text_document_uri(msg.params.as_ref()) {
                maybe_switch_active_file(state, debounce_tx, &uri).await;
            }
            // いずれも空配列が妥当な応答(本ブリッジは副作用目的)。
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, json!([])));
            }
        }
        _ => {
            // 未知のリクエストには空応答(Zed を待たせない)。
            if let Some(id) = msg.id {
                let _ = out.send(rpc_result(id, Value::Null));
            }
        }
    }
}

/// FR-030: レンダリング駆動リクエストの URI が現在のアクティブファイルと異なれば
/// タブ切替とみなし、カーソル未知(0:0, isEmpty=true, text="")で切り替えを push する。
/// 同一ファイルへの再リクエスト(スクロール・編集等)では既存の選択を上書きしない。
async fn maybe_switch_active_file(
    state: &Arc<SharedState>,
    debounce_tx: &mpsc::UnboundedSender<EditorContext>,
    uri: &str,
) {
    let cur = state.snapshot().await;
    if cur.file_url.as_deref() == Some(uri) {
        return;
    }
    trace_log("switch", "active_file", uri);
    let ctx = build_ctx(
        uri,
        Selection {
            start: Position::default(),
            end: Position::default(),
            is_empty: true,
        },
        String::new(),
    );
    let _ = debounce_tx.send(ctx);
}

/// トレースログ(実機検証用, FR-030 の research 補助)。
/// `CC_IDE_TRACE=<path>` か、`~/.cache/cc-ide/trace.on` が存在するとき
/// `~/.cache/cc-ide/trace.log` へ追記する。通常運用ではゼロコスト(初回判定のみ)。
fn trace_log(tag: &str, a: &str, b: &str) {
    static PATH: std::sync::OnceLock<Option<std::path::PathBuf>> = std::sync::OnceLock::new();
    let path = PATH.get_or_init(|| {
        if let Ok(p) = std::env::var("CC_IDE_TRACE") {
            return Some(std::path::PathBuf::from(p));
        }
        let home = std::env::var("HOME").ok()?;
        let dir = std::path::Path::new(&home).join(".cache").join("cc-ide");
        dir.join("trace.on").exists().then(|| dir.join("trace.log"))
    });
    if let Some(p) = path {
        use std::io::Write;
        if let Ok(mut f) = std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(p)
        {
            let _ = writeln!(f, "{tag}\t{a}\t{b}");
        }
    }
}

/// アクティブファイルのみ更新(選択は維持)。untitled は安全に無視(FR-023)。
async fn update_active_file(state: &Arc<SharedState>, uri: &str) {
    let mut ctx = state.snapshot().await;
    apply_uri(&mut ctx, uri);
    state.update(ctx).await;
}

/// uri + 選択 + 選択テキストから完全な EditorContext を作る。
fn build_ctx(uri: &str, sel: Selection, text: String) -> EditorContext {
    let mut ctx = EditorContext {
        selection: Some(sel),
        text,
        ..Default::default()
    };
    apply_uri(&mut ctx, uri);
    ctx
}

/// didOpen / didChange のパラメータから本文テキストを取り出す。
/// didOpen: params.textDocument.text、didChange(Full): params.contentChanges[last].text。
fn extract_document_text(params: Option<&Value>) -> Option<String> {
    let p = params?;
    if let Some(t) = p
        .get("textDocument")
        .and_then(|d| d.get("text"))
        .and_then(|v| v.as_str())
    {
        return Some(t.to_string());
    }
    // contentChanges は配列。Full 同期では最後の要素の text が全文。
    let changes = p.get("contentChanges")?.as_array()?;
    let last = changes.last()?;
    last.get("text")
        .and_then(|v| v.as_str())
        .map(|s| s.to_string())
}

/// 本文と選択範囲(0-origin の line/character)から選択テキストを切り出す。
/// LSP の character は UTF-16 単位だが、実用上 char 単位で近似する。
fn extract_range_text(content: &str, sel: &Selection) -> String {
    let lines: Vec<&str> = content.split('\n').collect();
    let (s, e) = (&sel.start, &sel.end);
    let (sl, el) = (s.line as usize, e.line as usize);
    if sl >= lines.len() {
        return String::new();
    }
    if sl == el {
        let chars: Vec<char> = lines[sl].chars().collect();
        let sc = (s.character as usize).min(chars.len());
        let ec = (e.character as usize).min(chars.len()).max(sc);
        return chars[sc..ec].iter().collect();
    }
    let mut out = String::new();
    #[allow(clippy::needless_range_loop)]
    for ln in sl..=el.min(lines.len().saturating_sub(1)) {
        let chars: Vec<char> = lines[ln].chars().collect();
        if ln == sl {
            let sc = (s.character as usize).min(chars.len());
            out.extend(&chars[sc..]);
            out.push('\n');
        } else if ln == el {
            let ec = (e.character as usize).min(chars.len());
            out.extend(&chars[..ec]);
        } else {
            out.push_str(lines[ln]);
            out.push('\n');
        }
    }
    out
}

/// file:// URI を filePath/fileUrl へ反映。非 file スキーム(untitled 等)は filePath 無しで安全に扱う。
fn apply_uri(ctx: &mut EditorContext, uri: &str) {
    if let Some(path) = uri.strip_prefix("file://") {
        ctx.file_path = Some(percent_decode(path));
        ctx.file_url = Some(uri.to_string());
    } else {
        // untitled:... など → アドレス不可だがエラーにしない(FR-023)。
        ctx.file_path = None;
        ctx.file_url = Some(uri.to_string());
    }
}

/// %XX をバイト単位でデコードして UTF-8 文字列へ復元する(日本語パス等のため)。
/// 不正な %XX(16進2桁が続かない)はそのまま残し、不正 UTF-8 は U+FFFD に置換する。
fn percent_decode(input: &str) -> String {
    let bytes = input.as_bytes();
    let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'%' && i + 2 < bytes.len() {
            let hi = (bytes[i + 1] as char).to_digit(16);
            let lo = (bytes[i + 2] as char).to_digit(16);
            if let (Some(hi), Some(lo)) = (hi, lo) {
                out.push((hi * 16 + lo) as u8);
                i += 3;
                continue;
            }
        }
        out.push(bytes[i]);
        i += 1;
    }
    String::from_utf8_lossy(&out).into_owned()
}

/// デバウンサ: 短時間に連続する更新を間引いて最後の1件のみ反映(FR-025)。
fn spawn_debouncer(
    mut rx: mpsc::UnboundedReceiver<EditorContext>,
    state: Arc<SharedState>,
    window: Duration,
) {
    tokio::spawn(async move {
        let mut pending: Option<EditorContext> = None;
        loop {
            tokio::select! {
                maybe = rx.recv() => {
                    match maybe {
                        Some(ctx) => { pending = Some(ctx); }
                        None => break, // チャネル閉鎖
                    }
                }
                _ = tokio::time::sleep(window), if pending.is_some() => {
                    if let Some(ctx) = pending.take() {
                        state.update(ctx).await;
                    }
                }
            }
        }
    });
}

fn server_capabilities() -> Value {
    json!({
        "capabilities": {
            "textDocumentSync": 1,            // Full
            "documentHighlightProvider": true,
            "codeActionProvider": true,
            "selectionRangeProvider": true,
            // FR-030: タブ切替捕捉用のレンダリング駆動シグナル群。
            // Zed が可視バッファへ発行するリクエストを受けるために宣言する
            // (応答は常に空。どれが実際に発火するかは Zed の設定・版に依存)。
            "documentSymbolProvider": true,
            "inlayHintProvider": true,
            "colorProvider": true,
            "foldingRangeProvider": true,
            "codeLensProvider": { "resolveProvider": false }
        },
        "serverInfo": { "name": "cc-ide-server", "version": env!("CARGO_PKG_VERSION") }
    })
}

// ---- params 抽出ヘルパ ----

fn parse_port_range(params: Option<&Value>) -> (u16, u16) {
    let default = (10000u16, 65535u16);
    let opts = match params.and_then(|p| p.get("initializationOptions")) {
        Some(o) => o,
        None => return default,
    };
    let min = opts
        .get("portRange")
        .and_then(|r| r.get("min"))
        .and_then(|v| v.as_u64())
        .map(|v| v as u16)
        .unwrap_or(default.0);
    let max = opts
        .get("portRange")
        .and_then(|r| r.get("max"))
        .and_then(|v| v.as_u64())
        .map(|v| v as u16)
        .unwrap_or(default.1);
    (min, max)
}

fn extract_uri(params: Option<&Value>) -> Option<String> {
    params?
        .get("textDocument")?
        .get("uri")?
        .as_str()
        .map(|s| s.to_string())
}

fn extract_text_document_uri(params: Option<&Value>) -> Option<String> {
    extract_uri(params)
}

fn extract_position(params: Option<&Value>) -> Option<Position> {
    let p = params?.get("position")?;
    Some(Position {
        line: p.get("line")?.as_u64()? as u32,
        character: p.get("character")?.as_u64()? as u32,
    })
}

fn extract_range_as_selection(params: Option<&Value>) -> Option<Selection> {
    let r = params?.get("range")?;
    let start = r.get("start")?;
    let end = r.get("end")?;
    let s = Position {
        line: start.get("line")?.as_u64()? as u32,
        character: start.get("character")?.as_u64()? as u32,
    };
    let e = Position {
        line: end.get("line")?.as_u64()? as u32,
        character: end.get("character")?.as_u64()? as u32,
    };
    let is_empty = s == e;
    Some(Selection {
        start: s,
        end: e,
        is_empty,
    })
}

/// LSP stdout への writer タスク。Content-Length フレームに包んで書き出す。
pub async fn writer_task<W>(mut w: W, mut rx: mpsc::UnboundedReceiver<Value>) -> Result<()>
where
    W: AsyncWriteExt + Unpin,
{
    while let Some(msg) = rx.recv().await {
        let body = serde_json::to_vec(&msg)?;
        let header = format!("Content-Length: {}\r\n\r\n", body.len());
        w.write_all(header.as_bytes()).await?;
        w.write_all(&body).await?;
        w.flush().await?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    // T024: documentHighlight の position → cursor 変換。
    #[test]
    fn position_extraction() {
        let params = json!({
            "textDocument": { "uri": "file:///a/b.rs" },
            "position": { "line": 12, "character": 4 }
        });
        let pos = extract_position(Some(&params)).expect("position");
        assert_eq!(pos.line, 12);
        assert_eq!(pos.character, 4);
    }

    // T024: codeAction の range → selection 変換(非空)。
    #[test]
    fn range_extraction_nonempty() {
        let params = json!({
            "textDocument": { "uri": "file:///a/b.rs" },
            "range": {
                "start": { "line": 1, "character": 0 },
                "end":   { "line": 3, "character": 7 }
            }
        });
        let sel = extract_range_as_selection(Some(&params)).expect("selection");
        assert_eq!(sel.start.line, 1);
        assert_eq!(sel.end.line, 3);
        assert!(!sel.is_empty);
    }

    // start==end のときは isEmpty=true(カーソルのみ)。
    #[test]
    fn range_extraction_empty() {
        let params = json!({
            "range": {
                "start": { "line": 5, "character": 2 },
                "end":   { "line": 5, "character": 2 }
            }
        });
        let sel = extract_range_as_selection(Some(&params)).expect("selection");
        assert!(sel.is_empty);
    }

    // file:// URI は filePath/fileUrl へ、untitled は filePath 無しで安全に(FR-023)。
    #[test]
    fn uri_apply_file_and_untitled() {
        let mut ctx = EditorContext::default();
        apply_uri(&mut ctx, "file:///Users/x/main.rs");
        assert_eq!(ctx.file_path.as_deref(), Some("/Users/x/main.rs"));

        let mut ctx2 = EditorContext::default();
        apply_uri(&mut ctx2, "untitled:Untitled-1");
        assert!(ctx2.file_path.is_none()); // エラーにせず None
    }

    // パーセントデコード: 日本語などマルチバイト文字を含むパスを復元する。
    #[test]
    fn uri_apply_percent_decodes_multibyte() {
        let mut ctx = EditorContext::default();
        apply_uri(
            &mut ctx,
            "file:///Users/x/ws/Go%E8%A8%80%E8%AA%9E%E5%AD%A6%E7%BF%92/2026-07-07%20Rails%E3%81%A8Go.md",
        );
        assert_eq!(
            ctx.file_path.as_deref(),
            Some("/Users/x/ws/Go言語学習/2026-07-07 RailsとGo.md")
        );
        // fileUrl はエンコードされた元の URI のまま保持する
        assert!(ctx.file_url.as_deref().unwrap().contains("%E8%A8%80"));
    }

    // percent_decode の境界: 不正な %XX はそのまま、% 直後の生マルチバイトで panic しない。
    #[test]
    fn percent_decode_edge_cases() {
        assert_eq!(percent_decode("a%2Gb"), "a%2Gb"); // 16進でない → そのまま
        assert_eq!(percent_decode("100%"), "100%"); // 末尾の % 単独
        assert_eq!(percent_decode("%あ"), "%あ"); // % 直後にマルチバイト → panic しない
        assert_eq!(percent_decode("%41%20%42"), "A B");
    }

    // 選択テキスト抽出(単一行・複数行)。
    #[test]
    fn range_text_single_and_multiline() {
        let content = "abcdef\nghijkl\nmnopqr";
        // 単一行: line0 char1..4 -> "bcd"
        let s = Selection {
            start: Position {
                line: 0,
                character: 1,
            },
            end: Position {
                line: 0,
                character: 4,
            },
            is_empty: false,
        };
        assert_eq!(extract_range_text(content, &s), "bcd");
        // 複数行: line0 char2 .. line2 char3 -> "cdef\nghijkl\nmno"
        let m = Selection {
            start: Position {
                line: 0,
                character: 2,
            },
            end: Position {
                line: 2,
                character: 3,
            },
            is_empty: false,
        };
        assert_eq!(extract_range_text(content, &m), "cdef\nghijkl\nmno");
    }

    // didOpen/didChange からの本文抽出。
    #[test]
    fn document_text_extraction() {
        let open = json!({"textDocument": {"uri":"file:///a","text":"hello"}});
        assert_eq!(extract_document_text(Some(&open)).as_deref(), Some("hello"));
        let change = json!({"contentChanges": [{"text":"world"}]});
        assert_eq!(
            extract_document_text(Some(&change)).as_deref(),
            Some("world")
        );
    }

    // FR-030: レンダリング駆動リクエスト(inlayHint 等)で URI が変われば
    // タブ切替として空選択のコンテキストがデバウンサへ送られる。
    #[tokio::test]
    async fn tab_switch_via_render_request() {
        let state = SharedState::new();
        // 現在のアクティブファイルは A。
        state
            .update(EditorContext {
                file_path: Some("/a.rs".into()),
                file_url: Some("file:///a.rs".into()),
                selection: None,
                text: String::new(),
            })
            .await;
        let (out_tx, _out_rx) = mpsc::unbounded_channel::<Value>();
        let (dbg_tx, mut dbg_rx) = mpsc::unbounded_channel::<EditorContext>();
        let mut init_tx: Option<oneshot::Sender<InitInfo>> = None;
        let mut docs = std::collections::HashMap::new();

        // B への inlayHint リクエスト → タブ切替として検知。
        let msg = RpcMessage {
            jsonrpc: Some("2.0".into()),
            id: Some(json!(7)),
            method: Some("textDocument/inlayHint".into()),
            params: Some(json!({ "textDocument": { "uri": "file:///b.rs" } })),
        };
        handle_message(msg, &out_tx, &state, &dbg_tx, &mut init_tx, &mut docs).await;
        let ctx = dbg_rx.try_recv().expect("switch push");
        assert_eq!(ctx.file_path.as_deref(), Some("/b.rs"));
        let sel = ctx.selection.expect("selection");
        assert!(sel.is_empty, "カーソル未知なので isEmpty");
        assert_eq!(ctx.text, "");
    }

    // FR-030: 同一ファイルへの再リクエスト(スクロール等)では push しない
    // (codeAction で得た選択を空選択で上書きしないため)。
    #[tokio::test]
    async fn same_file_render_request_is_noop() {
        let state = SharedState::new();
        state
            .update(EditorContext {
                file_path: Some("/a.rs".into()),
                file_url: Some("file:///a.rs".into()),
                selection: Some(Selection {
                    start: Position {
                        line: 1,
                        character: 2,
                    },
                    end: Position {
                        line: 3,
                        character: 4,
                    },
                    is_empty: false,
                }),
                text: "sel".into(),
            })
            .await;
        let (out_tx, _out_rx) = mpsc::unbounded_channel::<Value>();
        let (dbg_tx, mut dbg_rx) = mpsc::unbounded_channel::<EditorContext>();
        let mut init_tx: Option<oneshot::Sender<InitInfo>> = None;
        let mut docs = std::collections::HashMap::new();

        let msg = RpcMessage {
            jsonrpc: Some("2.0".into()),
            id: Some(json!(8)),
            method: Some("textDocument/documentSymbol".into()),
            params: Some(json!({ "textDocument": { "uri": "file:///a.rs" } })),
        };
        handle_message(msg, &out_tx, &state, &dbg_tx, &mut init_tx, &mut docs).await;
        assert!(dbg_rx.try_recv().is_err(), "同一ファイルでは push しない");
        // 状態も不変(選択を保持)。
        let cur = state.snapshot().await;
        assert_eq!(cur.text, "sel");
    }

    // FR-030: capabilities にレンダリング駆動シグナル群が宣言されている。
    #[test]
    fn render_signal_capabilities_declared() {
        let caps = server_capabilities();
        let c = &caps["capabilities"];
        assert_eq!(c["documentSymbolProvider"], json!(true));
        assert_eq!(c["inlayHintProvider"], json!(true));
        assert_eq!(c["colorProvider"], json!(true));
        assert_eq!(c["foldingRangeProvider"], json!(true));
        assert_eq!(c["codeLensProvider"]["resolveProvider"], json!(false));
    }

    // portRange の解析(initializationOptions)。
    #[test]
    fn port_range_parsing() {
        let params = json!({
            "initializationOptions": { "portRange": { "min": 20000, "max": 20100 } }
        });
        let (min, max) = parse_port_range(Some(&params));
        assert_eq!((min, max), (20000, 20100));
        // 欠落時は既定。
        let (dmin, dmax) = parse_port_range(None);
        assert_eq!((dmin, dmax), (10000, 65535));
    }
}