From 2ca8d7a28ae5e74f5a1dd51232c851328e3b7e14 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:39:21 +1100 Subject: [PATCH 01/39] Add server-to-client requests: Outbound handle, wire-rebuildable sidecar ids, JsonRpcError as std error (#48) --- crates/lspkit-server/src/jsonrpc.rs | 3 +- crates/lspkit-server/src/lib.rs | 2 + crates/lspkit-server/src/outbound.rs | 94 +++++++++ crates/lspkit-server/tests/outbound.rs | 221 ++++++++++++++++++++++ crates/lspkit/src/sidecar/correlator.rs | 7 + crates/lspkit/tests/sidecar_correlator.rs | 26 +++ docs/specs/lspkit-spec.md | 1 + 7 files changed, 353 insertions(+), 1 deletion(-) create mode 100644 crates/lspkit-server/src/outbound.rs create mode 100644 crates/lspkit-server/tests/outbound.rs diff --git a/crates/lspkit-server/src/jsonrpc.rs b/crates/lspkit-server/src/jsonrpc.rs index 00aaf9a..e9eb056 100644 --- a/crates/lspkit-server/src/jsonrpc.rs +++ b/crates/lspkit-server/src/jsonrpc.rs @@ -45,7 +45,8 @@ pub struct Message { } /// A JSON-RPC 2.0 error object. -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Debug, Clone, Serialize, Deserialize, thiserror::Error)] +#[error("JSON-RPC error {code}: {message}")] pub struct JsonRpcError { /// Numeric error code (see JSON-RPC spec for reserved ranges). pub code: i32, diff --git a/crates/lspkit-server/src/lib.rs b/crates/lspkit-server/src/lib.rs index 00646de..b2bbcff 100644 --- a/crates/lspkit-server/src/lib.rs +++ b/crates/lspkit-server/src/lib.rs @@ -23,6 +23,7 @@ pub mod jsonrpc; pub mod live; #[cfg(feature = "mcp")] pub mod mcp; +pub mod outbound; pub mod progress; #[cfg(feature = "pull")] pub mod pull; @@ -38,6 +39,7 @@ pub use crate::dispatch::{ CancellationHandle, DispatchError, Dispatcher, HandlerResult, RequestInterest, }; pub use crate::jsonrpc::{FramingError, JsonRpcError, Message, MessageWriter, RequestId}; +pub use crate::outbound::{Outbound, OutboundError, OutboundResponse, OutboundResult}; pub use crate::progress::{NoopReporter, ProgressReporter, ProgressSink, ProgressUpdate}; pub use crate::reply::{EmissionError, ReplyGate}; pub use crate::uri::{path_to_uri, uri_to_path, UriError}; diff --git a/crates/lspkit-server/src/outbound.rs b/crates/lspkit-server/src/outbound.rs new file mode 100644 index 0000000..ee137db --- /dev/null +++ b/crates/lspkit-server/src/outbound.rs @@ -0,0 +1,94 @@ +//! Server→client requests (`window/showDocument`, `workspace/diagnostic/refresh`). +//! [LSP-OUTBOUND] +//! +//! Ids come from the leak-proofed sidecar correlator, so an abandoned wait +//! unregisters itself on drop exactly as [SIDECAR-REQUEST-LIFETIME] requires. + +use lspkit::sidecar::{CorrelationError, Correlator, PendingResponse}; +use serde_json::Value; + +use crate::jsonrpc::{JsonRpcError, Message, RequestId}; + +/// What the editor answered: its `result`, or its JSON-RPC error. +pub type OutboundResult = Result; + +/// Resolves when the editor answers; dropping it unregisters the request. +pub type OutboundResponse = PendingResponse; + +/// Errors from matching an inbound message to a server request. +#[non_exhaustive] +#[derive(Debug, thiserror::Error)] +pub enum OutboundError { + /// The message is a request or notification, not a response. + #[error("message is not a response")] + NotAResponse, + /// No waiting server request has this id: foreign, answered or abandoned. + #[error("no pending server request for id {0:?}")] + UnknownId(RequestId), +} + +/// Allocates server request ids and routes the editor's answers back. +#[derive(Debug)] +pub struct Outbound { + /// The only pending table; entries leave when answered or abandoned. + correlator: Correlator, +} + +impl Outbound { + /// A handle with no pending requests. + #[must_use] + pub fn new() -> Self { + Self { + correlator: Correlator::new(), + } + } + + /// Build the request frame to write and the wait for its answer. + #[must_use] + pub fn request(&self, method: impl Into, params: Value) -> (Message, OutboundResponse) { + let (id, response) = self.correlator.register(); + // Ids count up from 1; i64::MAX would take 2^63 requests to reach. + let wire = RequestId::Number(i64::try_from(id.get()).unwrap_or(i64::MAX)); + (Message::request(wire, method, params), response) + } + + /// Deliver an inbound response to the request that is waiting for it. + /// + /// # Errors + /// [`OutboundError::NotAResponse`] for requests and notifications, and + /// [`OutboundError::UnknownId`] when no waiting request has the id. + pub fn resolve(&self, message: Message) -> Result<(), OutboundError> { + let (Some(id), None) = (message.id, message.method) else { + return Err(OutboundError::NotAResponse); + }; + let answer = message + .error + .map_or_else(|| Ok(message.result.unwrap_or(Value::Null)), Err); + let Some(raw) = correlated(&id) else { + return Err(OutboundError::UnknownId(id)); + }; + self.correlator.resolve(raw.into(), answer).map_err( + |_answered_or_abandoned: CorrelationError| OutboundError::UnknownId(id), + ) + } + + /// Requests still waiting for an answer. + #[must_use] + pub fn pending_count(&self) -> usize { + self.correlator.pending_count() + } +} + +impl Default for Outbound { + fn default() -> Self { + Self::new() + } +} + +/// The correlator number behind a wire id this handle could have allocated. +fn correlated(id: &RequestId) -> Option { + match id { + RequestId::Number(raw) => u64::try_from(*raw).ok(), + RequestId::String(_) => None, + } +} diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs new file mode 100644 index 0000000..77051e4 --- /dev/null +++ b/crates/lspkit-server/tests/outbound.rs @@ -0,0 +1,221 @@ +//! [LSP-OUTBOUND] Server→client requests over real Content-Length framing: +//! the server allocates the id, the editor answers on the wire, and the +//! decoded response resolves the waiting caller. Abandoned waits unregister. + +use lspkit_server::jsonrpc::read_message; +use lspkit_server::{ + JsonRpcError, Message, MessageWriter, Outbound, OutboundError, OutboundResponse, RequestId, +}; +use serde_json::{json, Value}; +use tokio::io::{duplex, BufReader, DuplexStream}; + +/// A wire step that fails the session with its cause. +type StepResult = Result>; + +/// Enough buffer for every frame these sessions exchange. +const PIPE_BYTES: usize = 64 * 1024; + +/// One direction of the editor connection, framed exactly as on stdio. +struct Wire { + writer: MessageWriter, + reader: BufReader, +} + +/// A connected server/editor pair. +fn connection() -> (Wire, Wire) { + let (server_out, editor_in) = duplex(PIPE_BYTES); + let (editor_out, server_in) = duplex(PIPE_BYTES); + ( + Wire { + writer: MessageWriter::new(server_out), + reader: BufReader::new(server_in), + }, + Wire { + writer: MessageWriter::new(editor_out), + reader: BufReader::new(editor_in), + }, + ) +} + +/// The editor reads one request and asserts its shape. +async fn editor_receives(editor: &mut Wire, method: &str, params: &Value) -> StepResult { + let request = read_message(&mut editor.reader).await?; + assert_eq!(request.jsonrpc, "2.0"); + assert_eq!(request.method.as_deref(), Some(method)); + // `"params": null` decodes as absent; both mean "no params" on the wire. + assert_eq!(request.params.as_ref().unwrap_or(&Value::Null), params); + let id = request.id.ok_or("a server request carries an id")?; + assert!(matches!(id, RequestId::Number(raw) if raw > 0), "{id:?}"); + Ok(id) +} + +/// The server sends `method`, and the editor reads exactly what was sent. +async fn round_trip( + outbound: &Outbound, + server: &Wire, + editor: &mut Wire, + method: &str, + params: Value, +) -> StepResult<(RequestId, OutboundResponse)> { + let (message, pending) = outbound.request(method, params.clone()); + server.writer.write_message(&message).await?; + let id = editor_receives(editor, method, ¶ms).await?; + assert_eq!( + message.id.as_ref(), + Some(&id), + "the wire carries the allocated id" + ); + Ok((id, pending)) +} + +/// The editor writes `reply`; the server reads it off the wire and resolves it. +async fn answer( + outbound: &Outbound, + server: &mut Wire, + editor: &Wire, + reply: &Message, +) -> StepResult> { + editor.writer.write_message(reply).await?; + Ok(outbound.resolve(read_message(&mut server.reader).await?)) +} + +/// [LSP-OUTBOUND] One editor session answering with a result, `null` and an error. +#[tokio::test] +async fn server_requests_resolve_from_the_editors_wire_answers() { + let (mut server, mut editor) = connection(); + let outbound = Outbound::new(); + assert_eq!(outbound.pending_count(), 0); + + // Success: window/showDocument answered with a result. + let show = json!({ "uri": "file:///tmp/a.rs", "takeFocus": true }); + let (show_id, show_wait) = + round_trip(&outbound, &server, &mut editor, "window/showDocument", show) + .await + .expect("request reaches the editor"); + assert_eq!(outbound.pending_count(), 1); + let shown = Message::response(show_id.clone(), json!({ "success": true })); + answer(&outbound, &mut server, &editor, &shown) + .await + .expect("wire") + .expect("answer matches"); + let shown = show_wait + .await + .expect("delivered") + .expect("the editor showed it"); + assert_eq!(shown, json!({ "success": true })); + assert_eq!(outbound.pending_count(), 0); + + // A `null` result (workspace/diagnostic/refresh) resolves to Value::Null. + let refresh = "workspace/diagnostic/refresh"; + let (refresh_id, refresh_wait) = + round_trip(&outbound, &server, &mut editor, refresh, Value::Null) + .await + .expect("request reaches the editor"); + assert_ne!(refresh_id, show_id, "ids are never reused"); + let null = Message::response(refresh_id, Value::Null); + answer(&outbound, &mut server, &editor, &null) + .await + .expect("wire") + .expect("null matches"); + assert_eq!( + refresh_wait + .await + .expect("delivered") + .expect("null is success"), + Value::Null + ); + + // Error: the editor's JsonRpcError reaches the caller, and it is a std error. + let missing = json!({ "uri": "file:///missing" }); + let (error_id, error_wait) = round_trip( + &outbound, + &server, + &mut editor, + "window/showDocument", + missing, + ) + .await + .expect("request reaches the editor"); + let refusal = + JsonRpcError::new(-32603, "document refused").with_data(json!({ "why": "closed" })); + let refused = Message::response_error(error_id, refusal); + answer(&outbound, &mut server, &editor, &refused) + .await + .expect("wire") + .expect("error matches"); + let error = error_wait + .await + .expect("delivered") + .expect_err("the editor refused"); + assert_eq!( + (error.code, error.message.as_str()), + (-32603, "document refused") + ); + assert_eq!(error.data, Some(json!({ "why": "closed" }))); + assert_eq!(error.to_string(), "JSON-RPC error -32603: document refused"); + let boxed: Box = Box::new(error); + assert_eq!(boxed.to_string(), "JSON-RPC error -32603: document refused"); + assert_eq!(outbound.pending_count(), 0); +} + +/// [LSP-OUTBOUND] [SIDECAR-REQUEST-LIFETIME] Abandoned waits leave no live entry, +/// and answers nobody waits for are rejected visibly, never dropped silently. +#[tokio::test] +async fn abandoned_waits_unregister_and_unmatched_messages_are_rejected() { + let (mut server, mut editor) = connection(); + let outbound = Outbound::new(); + let late_params = json!({ "uri": "file:///late" }); + let (late_id, late_wait) = round_trip( + &outbound, + &server, + &mut editor, + "window/showDocument", + late_params, + ) + .await + .expect("request reaches the editor"); + assert_eq!(outbound.pending_count(), 1); + drop(late_wait); + assert_eq!( + outbound.pending_count(), + 0, + "an abandoned wait leaves no live entry" + ); + let late_reply = Message::response(late_id.clone(), json!({ "success": true })); + let late = answer(&outbound, &mut server, &editor, &late_reply) + .await + .expect("wire") + .expect_err("nobody waits"); + assert!( + matches!(&late, OutboundError::UnknownId(id) if *id == late_id), + "{late:?}" + ); + assert_eq!( + late.to_string(), + format!("no pending server request for id {late_id:?}") + ); + + // Ids the server never allocated, and non-responses, are rejected visibly. + for foreign in [ + RequestId::String("editor-7".to_owned()), + RequestId::Number(-1), + RequestId::Number(9_999), + ] { + let rejected = outbound + .resolve(Message::response(foreign.clone(), Value::Null)) + .expect_err("foreign id"); + assert!( + matches!(&rejected, OutboundError::UnknownId(id) if *id == foreign), + "{rejected:?}" + ); + } + let notification = outbound + .resolve(Message::notification("$/progress", json!({}))) + .expect_err("not a response"); + assert!(matches!(notification, OutboundError::NotAResponse)); + let hover = Message::request(RequestId::Number(1), "textDocument/hover", json!({})); + let request = outbound.resolve(hover).expect_err("a request"); + assert!(matches!(request, OutboundError::NotAResponse)); + assert_eq!(request.to_string(), "message is not a response"); + assert_eq!(outbound.pending_count(), 0); +} diff --git a/crates/lspkit/src/sidecar/correlator.rs b/crates/lspkit/src/sidecar/correlator.rs index dc0b5c9..407069f 100644 --- a/crates/lspkit/src/sidecar/correlator.rs +++ b/crates/lspkit/src/sidecar/correlator.rs @@ -25,6 +25,13 @@ impl RequestId { } } +/// Rebuild an id from the raw number a peer echoes back on the wire. +impl From for RequestId { + fn from(raw: u64) -> Self { + Self(raw) + } +} + /// Errors from the correlator. #[non_exhaustive] #[derive(Debug, thiserror::Error)] diff --git a/crates/lspkit/tests/sidecar_correlator.rs b/crates/lspkit/tests/sidecar_correlator.rs index f20fb53..5dc3f0e 100644 --- a/crates/lspkit/tests/sidecar_correlator.rs +++ b/crates/lspkit/tests/sidecar_correlator.rs @@ -205,3 +205,29 @@ async fn pending_response_is_nameable_from_the_sidecar_facade() { assert_eq!(pending.await.expect("response delivered"), "answer"); assert_eq!(correlator.pending_count(), 0); } + +/// A response decoded off the wire carries only the raw number; it rebuilds the id. [SIDECAR-REQUEST-LIFETIME] +#[tokio::test] +async fn raw_wire_ids_rebuild_the_request_id_and_resolve() { + let correlator: Correlator<&str> = Correlator::new(); + let (first, first_wait) = correlator.register(); + let (second, second_wait) = correlator.register(); + let wire = serde_json::json!({ "id": second.get(), "result": "second" }); + let raw = wire + .get("id") + .and_then(serde_json::Value::as_u64) + .expect("numeric wire id"); + assert_eq!(RequestId::from(raw), second); + correlator + .resolve(RequestId::from(raw), "second") + .expect("rebuilt id resolves"); + correlator + .resolve(RequestId::from(first.get()), "first") + .expect("first resolves"); + assert_eq!(second_wait.await.expect("second delivered"), "second"); + assert_eq!(first_wait.await.expect("first delivered"), "first"); + assert!( + matches!(correlator.resolve(RequestId::from(raw), "again"), Err(CorrelationError::UnknownId(id)) if id == raw) + ); + assert_eq!(correlator.pending_count(), 0); +} diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 32a18e5..6b2b554 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -91,6 +91,7 @@ pub trait EngineApi: Send + Sync + 'static { ## Cross-cutting helpers — required behavior - **[SIDECAR-REQUEST-LIFETIME]** Dropping a correlator response future immediately unregisters and frees its response channel without another correlator call or a runtime. Abandoned IDs are no longer pending, so later responses return `UnknownId`; no cancellation tombstones accumulate. `register` returns `PendingResponse`, supporting `Future` and `try_recv`. A receiver holds only a weak registry reference, so it cannot prolong the correlator's lifetime. Inbound readers terminate when both destination receivers close, even without EOF or another frame. +- **[LSP-OUTBOUND]** Server→client requests (`lspkit-server::outbound::Outbound`): `request` allocates a numeric JSON-RPC id from the sidecar correlator and returns the request frame plus an `OutboundResponse` future. `resolve` routes an inbound response to its waiter as the editor's `result` (absent or `null` is `Value::Null`) or its `JsonRpcError`. Requests and notifications are `NotAResponse`; ids never allocated, already answered or abandoned are `UnknownId`. Dropping a wait unregisters it ([SIDECAR-REQUEST-LIFETIME]). `sidecar::RequestId` rebuilds from its raw wire number with `From`, and `JsonRpcError` implements `Display` and `std::error::Error`. - **Position encoding** (`lspkit::vfs::PositionEncoding`): negotiates encoding at `initialize` per LSP 3.17 client capabilities; converts on every read; round-trips byte/char offsets correctly across multi-byte scalars and surrogate pairs. - **URI ↔ `PathBuf`** (`lspkit-server::uri`): handles `file://`, percent-decoding, Windows drive letters, UNC paths, and non-UTF-8 paths. - **[URI-AUTHORITY]** A URI's authority is its host, never a path segment. An empty or `localhost` host names a local path; any other host names a UNC path (`file://server/share/a.rs` ↔ `\\server\share\a.rs`) on Windows and is an error elsewhere. `uri_to_path` never returns a relative path. `path_to_uri` removes the extended-length prefixes `\\?\` and `\\?\UNC\` that `std::fs::canonicalize` adds. From b42758e7294cc72230889978a220435cd382f318 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:41:37 +1100 Subject: [PATCH 02/39] Cover Outbound::default in the abandoned-wait session --- crates/lspkit-server/tests/outbound.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs index 77051e4..1c6a2b1 100644 --- a/crates/lspkit-server/tests/outbound.rs +++ b/crates/lspkit-server/tests/outbound.rs @@ -163,7 +163,8 @@ async fn server_requests_resolve_from_the_editors_wire_answers() { #[tokio::test] async fn abandoned_waits_unregister_and_unmatched_messages_are_rejected() { let (mut server, mut editor) = connection(); - let outbound = Outbound::new(); + let outbound = Outbound::default(); + assert_eq!(outbound.pending_count(), 0, "a default handle starts empty"); let late_params = json!({ "uri": "file:///late" }); let (late_id, late_wait) = round_trip( &outbound, From 3fbecfb02077bf3a912bd9d98fa89f89d7384cfb Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:44:34 +1100 Subject: [PATCH 03/39] Prove every Outbound outcome frees its heap; test result-less and null-id answers; document one handle per connection --- crates/lspkit-server/src/outbound.rs | 6 +- crates/lspkit-server/tests/outbound.rs | 25 +++++++ .../lspkit-server/tests/outbound_heap_leak.rs | 71 +++++++++++++++++++ 3 files changed, 101 insertions(+), 1 deletion(-) create mode 100644 crates/lspkit-server/tests/outbound_heap_leak.rs diff --git a/crates/lspkit-server/src/outbound.rs b/crates/lspkit-server/src/outbound.rs index ee137db..73cb512 100644 --- a/crates/lspkit-server/src/outbound.rs +++ b/crates/lspkit-server/src/outbound.rs @@ -28,6 +28,9 @@ pub enum OutboundError { } /// Allocates server request ids and routes the editor's answers back. +/// +/// Use exactly one handle per connection: ids are unique only within a handle, +/// so two handles on one connection would allocate the same ids. #[derive(Debug)] pub struct Outbound { /// The only pending table; entries leave when answered or abandoned. @@ -55,7 +58,8 @@ impl Outbound { /// Deliver an inbound response to the request that is waiting for it. /// /// # Errors - /// [`OutboundError::NotAResponse`] for requests and notifications, and + /// [`OutboundError::NotAResponse`] for requests, notifications and + /// `"id": null` error responses (they name no request to wake), and /// [`OutboundError::UnknownId`] when no waiting request has the id. pub fn resolve(&self, message: Message) -> Result<(), OutboundError> { let (Some(id), None) = (message.id, message.method) else { diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs index 1c6a2b1..0bfceee 100644 --- a/crates/lspkit-server/tests/outbound.rs +++ b/crates/lspkit-server/tests/outbound.rs @@ -125,6 +125,25 @@ async fn server_requests_resolve_from_the_editors_wire_answers() { Value::Null ); + // A frame with no `result` key at all is also success with Value::Null. + let (bare_id, bare_wait) = round_trip(&outbound, &server, &mut editor, refresh, Value::Null) + .await + .expect("request reaches the editor"); + let bare: Message = serde_json::from_value(json!({ "jsonrpc": "2.0", "id": bare_id })) + .expect("a result-less response frame decodes"); + assert!(bare.result.is_none() && bare.error.is_none()); + answer(&outbound, &mut server, &editor, &bare) + .await + .expect("wire") + .expect("bare answer matches"); + assert_eq!( + bare_wait + .await + .expect("delivered") + .expect("absent is success"), + Value::Null + ); + // Error: the editor's JsonRpcError reaches the caller, and it is a std error. let missing = json!({ "uri": "file:///missing" }); let (error_id, error_wait) = round_trip( @@ -214,6 +233,12 @@ async fn abandoned_waits_unregister_and_unmatched_messages_are_rejected() { .resolve(Message::notification("$/progress", json!({}))) .expect_err("not a response"); assert!(matches!(notification, OutboundError::NotAResponse)); + let null_id: Message = serde_json::from_value(json!({ + "jsonrpc": "2.0", "id": null, "error": { "code": -32700, "message": "parse error" } + })) + .expect("a null-id error frame decodes"); + let unaddressed = outbound.resolve(null_id).expect_err("names no request"); + assert!(matches!(unaddressed, OutboundError::NotAResponse)); let hover = Message::request(RequestId::Number(1), "textDocument/hover", json!({})); let request = outbound.resolve(hover).expect_err("a request"); assert!(matches!(request, OutboundError::NotAResponse)); diff --git a/crates/lspkit-server/tests/outbound_heap_leak.rs b/crates/lspkit-server/tests/outbound_heap_leak.rs new file mode 100644 index 0000000..93c904d --- /dev/null +++ b/crates/lspkit-server/tests/outbound_heap_leak.rs @@ -0,0 +1,71 @@ +//! [LSP-OUTBOUND] [MEM-FIX-SCOPE]: every server-request outcome frees its heap. +//! Single-test binary: the instrumented allocator sees no sibling tests. + +use lspkit_server::{JsonRpcError, Message, Outbound, OutboundError, RequestId}; +use serde_json::{json, Value}; + +#[path = "../../../test-support/state.rs"] +mod state; + +/// Enough lifetimes per outcome to expose cumulative retention. +const ROUNDS: usize = 32; +/// Heap bytes carried by each request's params and each answer. +const PAYLOAD_BYTES: usize = 16 * 1024; + +/// A payload that owns real heap memory. +fn payload() -> Value { + json!({ "blob": "x".repeat(PAYLOAD_BYTES) }) +} + +/// A lifetime whose outcome differs from the expected one. +type Mismatch = Box; + +/// Fail the lifetime with `what` unless `held`. +fn ensure(held: bool, what: &str) -> Result<(), Mismatch> { + if held { + Ok(()) + } else { + Err(what.into()) + } +} + +/// The id the server put on `sent`. +fn sent_id(sent: &Message) -> Result { + sent.id + .clone() + .ok_or_else(|| "a server request carries an id".into()) +} + +/// Answered, refused, abandoned and unmatched lifetimes, each fully released. +fn lifetimes(outbound: &Outbound) -> Result<(), Mismatch> { + for _ in 0..ROUNDS { + let (sent, mut answered) = outbound.request("window/showDocument", payload()); + outbound.resolve(Message::response(sent_id(&sent)?, payload()))?; + ensure(matches!(answered.try_recv(), Ok(Ok(_))), "answered")?; + let (sent, mut refused) = outbound.request("window/showDocument", payload()); + let refusal = JsonRpcError::new(-32603, "refused").with_data(payload()); + outbound.resolve(Message::response_error(sent_id(&sent)?, refusal))?; + ensure(matches!(refused.try_recv(), Ok(Err(_))), "refused")?; + let (sent, abandoned) = outbound.request("window/showDocument", payload()); + drop(abandoned); + let late = outbound.resolve(Message::response(sent_id(&sent)?, payload())); + ensure( + matches!(late, Err(OutboundError::UnknownId(_))), + "abandoned", + )?; + let foreign = Message::response(RequestId::String("editor".to_owned()), payload()); + ensure( + matches!(outbound.resolve(foreign), Err(OutboundError::UnknownId(_))), + "foreign", + )?; + } + Ok(()) +} + +#[test] +fn every_outbound_outcome_frees_its_heap_before_the_handle_drops() { + let outbound = Outbound::new(); + lifetimes(&outbound).expect("warm the pending table's capacity"); + state::assert_releases_heap(|| lifetimes(&outbound).expect("measured lifetimes")); + assert_eq!(outbound.pending_count(), 0); +} From 5498442413c8c6d9b7c91b994291f9cddb4b4994 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:46:09 +1100 Subject: [PATCH 04/39] =?UTF-8?q?Public-API=20regression=20for=20#49=20and?= =?UTF-8?q?=20red=E2=86=92green=20evidence=20for=20#21,=20#26,=20#48,=20#4?= =?UTF-8?q?9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/lspkit-server/tests/uri_authority.rs | 26 +++ docs/plans/issue-fix-evidence-21-26-48-49.md | 189 +++++++++++++++++++ 2 files changed, 215 insertions(+) create mode 100644 crates/lspkit-server/tests/uri_authority.rs create mode 100644 docs/plans/issue-fix-evidence-21-26-48-49.md diff --git a/crates/lspkit-server/tests/uri_authority.rs b/crates/lspkit-server/tests/uri_authority.rs new file mode 100644 index 0000000..ce97332 --- /dev/null +++ b/crates/lspkit-server/tests/uri_authority.rs @@ -0,0 +1,26 @@ +//! [URI-AUTHORITY] Issue #49 through the public API only, so this file also +//! compiles against the pre-fix crate and fails there on the exact symptom. + +use std::path::PathBuf; + +use lspkit_server::{path_to_uri, uri_to_path}; + +/// A `localhost` or empty authority is the host, never the first path folder. +#[cfg(not(windows))] +#[test] +fn localhost_authority_is_the_host_not_a_folder() { + for uri in [ + "file://localhost/tmp/a.rs", + "file://LOCALHOST/tmp/a.rs", + "file:///tmp/a.rs", + ] { + let path = uri_to_path(uri).expect("a local file URI decodes"); + assert_eq!(path, PathBuf::from("/tmp/a.rs"), "{uri}"); + assert!(path.is_absolute(), "{uri} never yields a relative path"); + assert_eq!(path_to_uri(&path).expect("encodes"), "file:///tmp/a.rs"); + } + assert!( + uri_to_path("file://server/share/a.rs").is_err(), + "a remote host has no Unix path" + ); +} diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md new file mode 100644 index 0000000..550dfc4 --- /dev/null +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -0,0 +1,189 @@ +# Red→green evidence for issues #21, #26, #48 and #49 + +Every fix below is proven the same way: put the pre-fix code back, run the named test and watch it fail on the issue's exact symptom, then restore the code and watch the same test pass. Run all commands from the repo root on branch `fix/issues-21-26-48-49`. Results were captured on macOS (aarch64), Rust 1.100.0. + +The reference-server suites drive the real compiled `diagnostic-reference` binary. Build it after every source change, because it links `lspkit`: + +```sh +cargo build -p lspkit-server --example diagnostic-reference --features pull --locked +export LSPKIT_REFERENCE_BIN=$PWD/target/debug/examples/diagnostic-reference +``` + +| Issue | Fixed in | Released | Regression test | +|---|---|---|---| +| #21 truncated frame read as clean EOF | `5590a52` (PR #27, added `next_frame` in `crates/lspkit-sidecar/src/inbound.rs`, now `crates/lspkit/src/sidecar/inbound.rs:109`) | v0.1.0 onward, including 0.5.0 | `crates/lspkit/tests/sidecar_disconnect_session.rs:79` `native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic` | +| #26 cancellation test drops the earlier partial | `741e806` (PR #33, `crates/lspkit-server/tests/cli_sessions/dispatcher.rs:90`) | v0.1.0 onward, including 0.5.0 | `crates/lspkit-server/tests/cli_sessions/dispatcher.rs:119` `cancel_during_a_scan_stops_the_stream_with_the_standard_error` | +| #49 URI host read as a path folder; UNC and `\\?\` paths | `384b341` (PR #50) | not yet; ships in v0.6.0 | `crates/lspkit-server/tests/uri_authority.rs` `localhost_authority_is_the_host_not_a_folder`; Windows rows in `crates/lspkit-server/src/uri_style_tests.rs:46` and `:57` | +| #48 no server→client requests | this branch | ships in v0.6.0 | `crates/lspkit-server/tests/outbound.rs:84` and `:183`, `crates/lspkit-server/tests/outbound_heap_leak.rs:66`, `crates/lspkit/tests/sidecar_correlator.rs:211` | + +## #21: a truncated frame is an error, not a clean end of stream + +The old reader turned every `UnexpectedEof` into "stream ended", including a peer that closes mid-prefix or mid-payload. The fix reads one byte first: zero bytes is a clean end, and anything else goes through the frame decoder, so a torn frame surfaces as an error. + +Red: put the old behaviour back, rebuild the reference binary, run the test. + +```diff +diff --git a/crates/lspkit/src/sidecar/inbound.rs b/crates/lspkit/src/sidecar/inbound.rs +index 0058be5..eb47a94 100644 +--- a/crates/lspkit/src/sidecar/inbound.rs ++++ b/crates/lspkit/src/sidecar/inbound.rs +@@ -3,7 +3,7 @@ + //! Codec and envelope classification belong to the caller. This layer only + //! separates response flow from unsolicited backend events. + +-use tokio::io::{AsyncRead, AsyncReadExt}; ++use tokio::io::{AsyncRead}; + use tokio::sync::mpsc; + use tokio::task::JoinHandle; + +@@ -110,18 +110,13 @@ async fn next_frame( + reader: &mut R, + max_frame: usize, + ) -> Result>, String> { +- let mut first = [0]; +- if reader +- .read(&mut first) +- .await +- .map_err(|error| error.to_string())? +- == 0 +- { +- return Ok(None); ++ match read_frame(reader, max_frame).await { ++ Ok(frame) => Ok(Some(frame)), ++ Err(crate::sidecar::transport::TransportError::Io(e)) ++ if e.kind() == std::io::ErrorKind::UnexpectedEof => ++ { ++ Ok(None) ++ } ++ Err(error) => Err(error.to_string()), + } +- let mut prefixed = std::io::Cursor::new(first).chain(reader); +- read_frame(&mut prefixed, max_frame) +- .await +- .map(Some) +- .map_err(|error| error.to_string()) + } +``` + +```sh +git apply red-21.patch # the diff above +cargo build -p lspkit-server --example diagnostic-reference --features pull --locked +cargo nextest run -p lspkit --all-features --test sidecar_disconnect_session +``` + +```text + FAIL [ 0.549s] (2/2) lspkit::sidecar_disconnect_session native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic + thread 'native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic' (1754426) panicked at crates/lspkit/tests/sidecar_disconnect_session.rs:48:5: + left: 0 + right: 1 + FAIL [ 0.549s] (2/2) lspkit::sidecar_disconnect_session native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic +``` + +`sidecar_disconnect_session.rs:48` asserts exactly one terminal read error: the old code produced zero, so the torn frame looked like a clean EOF. Green, after `git checkout crates/lspkit/src/sidecar/inbound.rs` and a rebuild: + +```text + Summary [ 0.640s] 2 tests run: 2 passed, 0 skipped +``` + +## #26: the earlier partial result is kept when the scan is cancelled + +#26 was a bug in the test, not the server: the test consumed the first partial as a barrier and then checked only the partials that came after it. Correct server behaviour therefore failed the count. The fix chains the barrier back into the checked list. The server streams one partial per document before the hold, and the test asserts all 64, that every one is a distinct scan document, that the held document never streamed, and that the terminal reply is the standard `-32800`. + +Red: put the old assertion back and run it against the correct server. + +```diff +diff --git a/crates/lspkit-server/tests/cli_sessions/dispatcher.rs b/crates/lspkit-server/tests/cli_sessions/dispatcher.rs +index d521142..d75f212 100644 +--- a/crates/lspkit-server/tests/cli_sessions/dispatcher.rs ++++ b/crates/lspkit-server/tests/cli_sessions/dispatcher.rs +@@ -87,7 +87,8 @@ fn assert_streamed_up_to_the_hold( + barrier: &Value, + partials: &[Value], + ) { +- let streamed: Vec<&Value> = std::iter::once(barrier).chain(partials).collect(); ++ let _ = barrier; ++ let streamed: Vec<&Value> = partials.iter().collect(); + for partial in &streamed { + assert_partial_document(partial); + } +``` + +```sh +cargo nextest run -p lspkit-server --all-features --test diagnostic_reference cancel_during_a_scan +``` + +```text + FAIL [ 0.027s] (1/1) lspkit-server::diagnostic_reference dispatcher::cancel_during_a_scan_stops_the_stream_with_the_standard_error + thread 'dispatcher::cancel_during_a_scan_stops_the_stream_with_the_standard_error' (1757217) panicked at crates/lspkit-server/tests/cli_sessions/dispatcher.rs:100:5: + left: 63 + right: 64 + FAIL [ 0.027s] (1/1) lspkit-server::diagnostic_reference dispatcher::cancel_during_a_scan_stops_the_stream_with_the_standard_error +``` + +63 is not 64 because the old check dropped `scan-0000.json`, the earlier partial. Green, after `git checkout crates/lspkit-server/tests/cli_sessions/dispatcher.rs`: + +```text + Summary [ 0.028s] 1 test run: 1 passed, 25 skipped +``` + +## #49: a URI's host is a host, never a path folder + +Red: restore the pre-fix `uri.rs` and run the public-API test. + +```sh +git show 384b341^:crates/lspkit-server/src/uri.rs > crates/lspkit-server/src/uri.rs +cargo nextest run -p lspkit-server --test uri_authority +``` + +```text + FAIL [ 0.007s] (1/1) lspkit-server::uri_authority localhost_authority_is_the_host_not_a_folder + thread 'localhost_authority_is_the_host_not_a_folder' (1760196) panicked at crates/lspkit-server/tests/uri_authority.rs:18:9: + left: "/localhost/tmp/a.rs" + right: "/tmp/a.rs" +``` + +This is the issue's row `file://localhost/tmp/a.rs` → `/localhost/tmp/a.rs`. Green, after `git checkout crates/lspkit-server/src/uri.rs`: + +```text + Summary [ 0.015s] 1 test run: 1 passed, 0 skipped +``` + +The Windows rows (UNC `file://server/share/a.rs` ↔ `\\server\share\a.rs`, `file://wsl.localhost/…`, and `\\?\C:\…` and `\\?\UNC\…` → URI) are unit tests in `uri_style_tests.rs`. They call the Windows conversion directly, so Linux and macOS CI run them on every PR. + +## #48: the server can send its own requests to the editor + +`lspkit_server::Outbound` allocates a numeric JSON-RPC id, returns the request frame and an `OutboundResponse` future, and `resolve` delivers the editor's answer. The tests run over real Content-Length framing on a duplex stream. + +- A `window/showDocument` request reaches the editor with its method, params and id, the editor's `{"success": true}` comes back to the caller, and ids are never reused. +- A `null` result and a frame with no `result` key both resolve to `Value::Null` (`workspace/diagnostic/refresh`). +- An editor `JsonRpcError` reaches the caller with its code, message and data. It renders as `JSON-RPC error -32603: document refused` through `Display` and through `Box`. +- Dropping a wait unregisters it at once (`pending_count` 1 → 0), and the late answer is `UnknownId`. +- String, negative and never-allocated ids are `UnknownId`. Notifications, requests and `"id": null` errors are `NotAResponse`. +- `outbound_heap_leak.rs` runs 32 rounds of answered, refused, abandoned and foreign lifetimes and asserts that allocated heap bytes equal freed bytes. Replacing `drop(abandoned)` with `std::mem::forget(abandoned)` makes it fail, which shows the test detects retention. +- `sidecar::RequestId::from(raw)` rebuilds an id from the raw wire number and resolves. + +Red: remove the fix and keep the tests. + +```sh +git diff main -- crates/lspkit-server/src crates/lspkit/src > fix-48.patch +git apply -R fix-48.patch +cargo test -p lspkit-server --test outbound --test outbound_heap_leak --no-run +cargo test -p lspkit --test sidecar_correlator --no-run +``` + +```text +error[E0432]: unresolved imports `lspkit_server::Outbound`, `lspkit_server::OutboundError` +error[E0432]: unresolved imports `lspkit_server::Outbound`, `lspkit_server::OutboundError`, `lspkit_server::OutboundResponse` + | --------------- ^^^ expected `RequestId`, found `u64` + | --------------- ^^^ expected `RequestId`, found `u64` + | --------------- ^^^^^^^^^^^ expected `RequestId`, found `u64` + | --------------- ^^^ expected `RequestId`, found `u64` +error[E0308]: mismatched types +``` + +Green, after `git apply fix-48.patch`: + +```text + Summary [ 0.010s] 3 tests run: 3 passed, 0 skipped + Summary [ 0.012s] 12 tests run: 12 passed, 0 skipped +``` From efeecf68096cbc2add75cb33ac458b85da9e275d Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:48:05 +1100 Subject: [PATCH 05/39] Omit null params on the wire (JSON-RPC 2.0); test duplicate answers, handle shutdown and percent-encoded UNC hosts --- crates/lspkit-server/src/jsonrpc.rs | 13 +++-- crates/lspkit-server/src/uri_style_tests.rs | 7 ++- crates/lspkit-server/tests/outbound.rs | 51 ++++++++++++++++++++ docs/plans/issue-fix-evidence-21-26-48-49.md | 6 ++- 4 files changed, 71 insertions(+), 6 deletions(-) diff --git a/crates/lspkit-server/src/jsonrpc.rs b/crates/lspkit-server/src/jsonrpc.rs index e9eb056..4b88dcf 100644 --- a/crates/lspkit-server/src/jsonrpc.rs +++ b/crates/lspkit-server/src/jsonrpc.rs @@ -77,27 +77,27 @@ impl JsonRpcError { } impl Message { - /// Construct a request with `id`, `method`, and `params`. + /// Construct a request with `id`, `method`, and `params` (omitted when `null`). #[must_use] pub fn request(id: RequestId, method: impl Into, params: Value) -> Self { Self { jsonrpc: "2.0".to_owned(), id: Some(id), method: Some(method.into()), - params: Some(params), + params: wire_params(params), result: None, error: None, } } - /// Construct a notification with `method` and `params`. + /// Construct a notification with `method` and `params` (omitted when `null`). #[must_use] pub fn notification(method: impl Into, params: Value) -> Self { Self { jsonrpc: "2.0".to_owned(), id: None, method: Some(method.into()), - params: Some(params), + params: wire_params(params), result: None, error: None, } @@ -130,6 +130,11 @@ impl Message { } } +/// JSON-RPC 2.0 `params` is an object, an array, or omitted, never `null`. +fn wire_params(params: Value) -> Option { + (!params.is_null()).then_some(params) +} + /// Errors from reading or writing JSON-RPC messages. #[non_exhaustive] #[derive(Debug, thiserror::Error)] diff --git a/crates/lspkit-server/src/uri_style_tests.rs b/crates/lspkit-server/src/uri_style_tests.rs index 3582396..d577826 100644 --- a/crates/lspkit-server/src/uri_style_tests.rs +++ b/crates/lspkit-server/src/uri_style_tests.rs @@ -4,7 +4,7 @@ use super::{native_to_uri, uri_to_native, Style, UriError}; /// URIs, the Windows path each names, and the URI that path encodes back to. -const WINDOWS_ROUND_TRIPS: [(&str, &str, &str); 5] = [ +const WINDOWS_ROUND_TRIPS: [(&str, &str, &str); 6] = [ ( "file:///C:/repo/a.rs", r"C:\repo\a.rs", @@ -21,6 +21,11 @@ const WINDOWS_ROUND_TRIPS: [(&str, &str, &str); 5] = [ r"\\server\share\a.rs", "file://server/share/a.rs", ), + ( + "file://build%2Dhost/share%20one/a.rs", + r"\\build-host\share one\a.rs", + "file://build-host/share%20one/a.rs", + ), ( "file://wsl.localhost/Ubuntu/home/a.rs", r"\\wsl.localhost\Ubuntu\home\a.rs", diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs index 0bfceee..096c86e 100644 --- a/crates/lspkit-server/tests/outbound.rs +++ b/crates/lspkit-server/tests/outbound.rs @@ -112,6 +112,16 @@ async fn server_requests_resolve_from_the_editors_wire_answers() { .await .expect("request reaches the editor"); assert_ne!(refresh_id, show_id, "ids are never reused"); + // JSON-RPC 2.0: `params` is an object, an array, or omitted, never `null`. + let (refresh_frame, refresh_unsent) = outbound.request(refresh, Value::Null); + let wire = serde_json::to_value(&refresh_frame).expect("the frame serializes"); + assert_eq!( + wire.get("params"), + None, + "a parameterless request omits params: {wire}" + ); + assert_eq!(wire.get("method"), Some(&json!(refresh))); + drop(refresh_unsent); let null = Message::response(refresh_id, Value::Null); answer(&outbound, &mut server, &editor, &null) .await @@ -244,4 +254,45 @@ async fn abandoned_waits_unregister_and_unmatched_messages_are_rejected() { assert!(matches!(request, OutboundError::NotAResponse)); assert_eq!(request.to_string(), "message is not a response"); assert_eq!(outbound.pending_count(), 0); + + // The editor answers the same id twice: the duplicate is unmatched. + let (twice_id, twice_wait) = round_trip( + &outbound, + &server, + &mut editor, + "window/showDocument", + json!({}), + ) + .await + .expect("request reaches the editor"); + let reply = Message::response(twice_id.clone(), json!({ "success": true })); + answer(&outbound, &mut server, &editor, &reply) + .await + .expect("wire") + .expect("first answer"); + let again = answer(&outbound, &mut server, &editor, &reply) + .await + .expect("wire") + .expect_err("duplicate"); + assert!( + matches!(&again, OutboundError::UnknownId(id) if *id == twice_id), + "{again:?}" + ); + assert!(twice_wait.await.expect("first delivered").is_ok()); + + // Shutdown: dropping the handle closes every live wait instead of hanging it. + let (_, orphaned) = round_trip( + &outbound, + &server, + &mut editor, + "window/showDocument", + json!({}), + ) + .await + .expect("request reaches the editor"); + drop(outbound); + assert!( + orphaned.await.is_err(), + "a wait outliving its handle ends with RecvError" + ); } diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 550dfc4..3ba1029 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -148,7 +148,7 @@ This is the issue's row `file://localhost/tmp/a.rs` → `/localhost/tmp/a.rs`. G Summary [ 0.015s] 1 test run: 1 passed, 0 skipped ``` -The Windows rows (UNC `file://server/share/a.rs` ↔ `\\server\share\a.rs`, `file://wsl.localhost/…`, and `\\?\C:\…` and `\\?\UNC\…` → URI) are unit tests in `uri_style_tests.rs`. They call the Windows conversion directly, so Linux and macOS CI run them on every PR. +The Windows rows (UNC `file://server/share/a.rs` ↔ `\\server\share\a.rs`, `file://wsl.localhost/…`, and `\\?\C:\…` and `\\?\UNC\…` → URI) and a percent-encoded host (`file://build%2Dhost/share%20one/a.rs` ↔ `\\build-host\share one\a.rs`) are unit tests in `uri_style_tests.rs`. They call the Windows conversion directly, so Linux and macOS CI run them on every PR. CI has no Windows runner, so the `cfg(windows)` selection of that branch is not executed in CI. ## #48: the server can send its own requests to the editor @@ -160,6 +160,10 @@ The Windows rows (UNC `file://server/share/a.rs` ↔ `\\server\share\a.rs`, `fil - Dropping a wait unregisters it at once (`pending_count` 1 → 0), and the late answer is `UnknownId`. - String, negative and never-allocated ids are `UnknownId`. Notifications, requests and `"id": null` errors are `NotAResponse`. - `outbound_heap_leak.rs` runs 32 rounds of answered, refused, abandoned and foreign lifetimes and asserts that allocated heap bytes equal freed bytes. Replacing `drop(abandoned)` with `std::mem::forget(abandoned)` makes it fail, which shows the test detects retention. +- A parameterless request (`workspace/diagnostic/refresh`) omits `params` on the wire instead of sending `"params": null`, which JSON-RPC 2.0 forbids. `Message::request` and `Message::notification` both omit `null` params. Red before the fix: `outbound.rs` asserted `left: Some(Null) right: None` on `{"id":3,"jsonrpc":"2.0","method":"workspace/diagnostic/refresh","params":null}`. +- A duplicate answer for an already answered id is `UnknownId`, and the first answer still reaches its caller. +- Dropping the `Outbound` handle (server shutdown) ends every live wait with `RecvError` instead of hanging it. +- A client that never answers keeps exactly one entry until the caller drops its wait. Dropping is how a server cancels its own request; sending `$/cancelRequest` to the editor stays the caller's choice. - `sidecar::RequestId::from(raw)` rebuilds an id from the raw wire number and resolves. Red: remove the fix and keep the tests. From 95865df4edef5b113b200f969ab26a4d6a94ac8b Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:52:28 +1100 Subject: [PATCH 06/39] Outbound: fail with IdsExhausted past i64::MAX instead of reusing a wire id; prove answers route only to their own wait --- crates/lspkit-server/src/outbound.rs | 58 +++++++++++++++++-- crates/lspkit-server/tests/outbound.rs | 47 ++++++++++++++- .../lspkit-server/tests/outbound_heap_leak.rs | 6 +- docs/plans/issue-fix-evidence-21-26-48-49.md | 45 +++++++++++++- docs/specs/lspkit-spec.md | 2 +- 5 files changed, 146 insertions(+), 12 deletions(-) diff --git a/crates/lspkit-server/src/outbound.rs b/crates/lspkit-server/src/outbound.rs index 73cb512..853b682 100644 --- a/crates/lspkit-server/src/outbound.rs +++ b/crates/lspkit-server/src/outbound.rs @@ -25,6 +25,9 @@ pub enum OutboundError { /// No waiting server request has this id: foreign, answered or abandoned. #[error("no pending server request for id {0:?}")] UnknownId(RequestId), + /// The correlator id no longer fits a JSON-RPC number on the wire. + #[error("server request id {0} exceeds the largest JSON-RPC number")] + IdsExhausted(u64), } /// Allocates server request ids and routes the editor's answers back. @@ -47,12 +50,20 @@ impl Outbound { } /// Build the request frame to write and the wait for its answer. - #[must_use] - pub fn request(&self, method: impl Into, params: Value) -> (Message, OutboundResponse) { + /// + /// # Errors + /// [`OutboundError::IdsExhausted`] once ids pass the largest JSON-RPC + /// number; the registration is released, never reused. + pub fn request( + &self, + method: impl Into, + params: Value, + ) -> Result<(Message, OutboundResponse), OutboundError> { let (id, response) = self.correlator.register(); - // Ids count up from 1; i64::MAX would take 2^63 requests to reach. - let wire = RequestId::Number(i64::try_from(id.get()).unwrap_or(i64::MAX)); - (Message::request(wire, method, params), response) + Ok(( + Message::request(wire_id(id.get())?, method, params), + response, + )) } /// Deliver an inbound response to the request that is waiting for it. @@ -89,6 +100,13 @@ impl Default for Outbound { } } +/// The wire id for correlator id `raw`; past `i64::MAX` it fails, never collides. +fn wire_id(raw: u64) -> Result { + i64::try_from(raw) + .map(RequestId::Number) + .map_err(|_beyond_wire_numbers| OutboundError::IdsExhausted(raw)) +} + /// The correlator number behind a wire id this handle could have allocated. fn correlated(id: &RequestId) -> Option { match id { @@ -96,3 +114,33 @@ fn correlated(id: &RequestId) -> Option { RequestId::String(_) => None, } } + +// Reaching 2^63 real registrations is infeasible, so the boundary is isolated here. +#[cfg(test)] +mod tests { + use super::{correlated, wire_id, OutboundError, RequestId}; + + #[test] + fn ids_past_the_largest_json_rpc_number_fail_instead_of_colliding() { + let largest = u64::try_from(i64::MAX).expect("i64::MAX is non-negative"); + let last = wire_id(largest).expect("the largest number is still a valid id"); + assert_eq!(last, RequestId::Number(i64::MAX)); + assert_eq!( + correlated(&last), + Some(largest), + "the last valid id round-trips" + ); + for beyond in [largest + 1, largest + 2, u64::MAX] { + let error = wire_id(beyond).expect_err("no wire number left"); + assert!( + matches!(error, OutboundError::IdsExhausted(raw) if raw == beyond), + "{error:?}" + ); + assert_eq!( + error.to_string(), + format!("server request id {beyond} exceeds the largest JSON-RPC number") + ); + } + assert_eq!(wire_id(1).expect("first id"), RequestId::Number(1)); + } +} diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs index 096c86e..25fd2f1 100644 --- a/crates/lspkit-server/tests/outbound.rs +++ b/crates/lspkit-server/tests/outbound.rs @@ -57,7 +57,7 @@ async fn round_trip( method: &str, params: Value, ) -> StepResult<(RequestId, OutboundResponse)> { - let (message, pending) = outbound.request(method, params.clone()); + let (message, pending) = outbound.request(method, params.clone())?; server.writer.write_message(&message).await?; let id = editor_receives(editor, method, ¶ms).await?; assert_eq!( @@ -113,7 +113,9 @@ async fn server_requests_resolve_from_the_editors_wire_answers() { .expect("request reaches the editor"); assert_ne!(refresh_id, show_id, "ids are never reused"); // JSON-RPC 2.0: `params` is an object, an array, or omitted, never `null`. - let (refresh_frame, refresh_unsent) = outbound.request(refresh, Value::Null); + let (refresh_frame, refresh_unsent) = outbound + .request(refresh, Value::Null) + .expect("an id is available"); let wire = serde_json::to_value(&refresh_frame).expect("the frame serializes"); assert_eq!( wire.get("params"), @@ -296,3 +298,44 @@ async fn abandoned_waits_unregister_and_unmatched_messages_are_rejected() { "a wait outliving its handle ends with RecvError" ); } + +/// [LSP-OUTBOUND] Three requests in flight, answered out of order on the wire: +/// each editor answer wakes exactly the wait whose id it carries, never another. +#[tokio::test] +async fn out_of_order_answers_wake_only_the_wait_with_their_id() { + let (mut server, mut editor) = connection(); + let outbound = Outbound::new(); + let mut waits = Vec::new(); + for name in ["first", "second", "third"] { + let params = json!({ "uri": format!("file:///{name}.rs") }); + let (id, wait) = round_trip( + &outbound, + &server, + &mut editor, + "window/showDocument", + params, + ) + .await + .expect("request reaches the editor"); + waits.push((name, id, wait)); + } + assert_eq!(outbound.pending_count(), 3); + // The editor answers third, then first, then second; each answer names its request. + for index in [2, 0, 1] { + let (name, id, _) = waits.get(index).expect("a sent request"); + let reply = Message::response(id.clone(), json!({ "answered": name })); + answer(&outbound, &mut server, &editor, &reply) + .await + .expect("wire") + .expect("the answer's id is pending"); + } + assert_eq!(outbound.pending_count(), 0); + for (name, id, wait) in waits { + let got = wait.await.expect("delivered").expect("success"); + assert_eq!( + got, + json!({ "answered": name }), + "wait for {id:?} got another request's answer" + ); + } +} diff --git a/crates/lspkit-server/tests/outbound_heap_leak.rs b/crates/lspkit-server/tests/outbound_heap_leak.rs index 93c904d..3e0776c 100644 --- a/crates/lspkit-server/tests/outbound_heap_leak.rs +++ b/crates/lspkit-server/tests/outbound_heap_leak.rs @@ -39,14 +39,14 @@ fn sent_id(sent: &Message) -> Result { /// Answered, refused, abandoned and unmatched lifetimes, each fully released. fn lifetimes(outbound: &Outbound) -> Result<(), Mismatch> { for _ in 0..ROUNDS { - let (sent, mut answered) = outbound.request("window/showDocument", payload()); + let (sent, mut answered) = outbound.request("window/showDocument", payload())?; outbound.resolve(Message::response(sent_id(&sent)?, payload()))?; ensure(matches!(answered.try_recv(), Ok(Ok(_))), "answered")?; - let (sent, mut refused) = outbound.request("window/showDocument", payload()); + let (sent, mut refused) = outbound.request("window/showDocument", payload())?; let refusal = JsonRpcError::new(-32603, "refused").with_data(payload()); outbound.resolve(Message::response_error(sent_id(&sent)?, refusal))?; ensure(matches!(refused.try_recv(), Ok(Err(_))), "refused")?; - let (sent, abandoned) = outbound.request("window/showDocument", payload()); + let (sent, abandoned) = outbound.request("window/showDocument", payload())?; drop(abandoned); let late = outbound.resolve(Message::response(sent_id(&sent)?, payload())); ensure( diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 3ba1029..46150ef 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -166,7 +166,50 @@ The Windows rows (UNC `file://server/share/a.rs` ↔ `\\server\share\a.rs`, `fil - A client that never answers keeps exactly one entry until the caller drops its wait. Dropping is how a server cancels its own request; sending `$/cancelRequest` to the editor stays the caller's choice. - `sidecar::RequestId::from(raw)` rebuilds an id from the raw wire number and resolves. -Red: remove the fix and keep the tests. +### Behavioural red: an answer wakes only its own request + +`outbound.rs` `out_of_order_answers_wake_only_the_wait_with_their_id` sends three requests, and the editor answers them third, first, second. Each wait must receive the answer carrying its own id. Mutate `resolve` so it rotates ids, so that every answer wakes another pending request while every resolve still succeeds: + +```diff +diff --git a/crates/lspkit-server/src/outbound.rs b/crates/lspkit-server/src/outbound.rs +index 73cb512..9eeedd2 100644 +--- a/crates/lspkit-server/src/outbound.rs ++++ b/crates/lspkit-server/src/outbound.rs +@@ -71,7 +71,7 @@ impl Outbound { + let Some(raw) = correlated(&id) else { + return Err(OutboundError::UnknownId(id)); + }; +- self.correlator.resolve(raw.into(), answer).map_err( ++ self.correlator.resolve(((raw % 3) + 1).into(), answer).map_err( + |_answered_or_abandoned: CorrelationError| OutboundError::UnknownId(id), + ) + } +``` + +```text + thread 'out_of_order_answers_wake_only_the_wait_with_their_id' (1855494) panicked at crates/lspkit-server/tests/outbound.rs:333:9: + assertion `left == right` failed: wait for Number(1) got another request's answer + left: Object {"answered": String("third")} + right: Object {"answered": String("first")} + Summary [ 0.010s] 1 test run: 0 passed, 1 failed, 2 skipped +``` + +Restored, all outbound tests pass. + +### Behavioural red: ids past `i64::MAX` fail instead of colliding + +The unit test `outbound::tests::ids_past_the_largest_json_rpc_number_fail_instead_of_colliding` (`crates/lspkit-server/src/outbound.rs`) checks the id boundary directly, because reaching 2^63 real registrations is not feasible. Before the fix `wire_id` saturated: + +```text +panicked at crates/lspkit-server/src/outbound.rs:132:41: +no wire number left: Number(9223372036854775807) +``` + +So id 2^63 went out as `9223372036854775807`, the same number as id 2^63 − 1. Now `request` returns `OutboundError::IdsExhausted(raw)` and drops the registration. + +### Compile red: the API did not exist + +Remove the fix and keep the tests. ```sh git diff main -- crates/lspkit-server/src crates/lspkit/src > fix-48.patch diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 6b2b554..8051b3f 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -91,7 +91,7 @@ pub trait EngineApi: Send + Sync + 'static { ## Cross-cutting helpers — required behavior - **[SIDECAR-REQUEST-LIFETIME]** Dropping a correlator response future immediately unregisters and frees its response channel without another correlator call or a runtime. Abandoned IDs are no longer pending, so later responses return `UnknownId`; no cancellation tombstones accumulate. `register` returns `PendingResponse`, supporting `Future` and `try_recv`. A receiver holds only a weak registry reference, so it cannot prolong the correlator's lifetime. Inbound readers terminate when both destination receivers close, even without EOF or another frame. -- **[LSP-OUTBOUND]** Server→client requests (`lspkit-server::outbound::Outbound`): `request` allocates a numeric JSON-RPC id from the sidecar correlator and returns the request frame plus an `OutboundResponse` future. `resolve` routes an inbound response to its waiter as the editor's `result` (absent or `null` is `Value::Null`) or its `JsonRpcError`. Requests and notifications are `NotAResponse`; ids never allocated, already answered or abandoned are `UnknownId`. Dropping a wait unregisters it ([SIDECAR-REQUEST-LIFETIME]). `sidecar::RequestId` rebuilds from its raw wire number with `From`, and `JsonRpcError` implements `Display` and `std::error::Error`. +- **[LSP-OUTBOUND]** Server→client requests (`lspkit-server::outbound::Outbound`): `request` allocates a numeric JSON-RPC id from the sidecar correlator and returns the request frame plus an `OutboundResponse` future; once ids pass `i64::MAX` it returns `IdsExhausted` instead of reusing a number. `null` params are omitted from the frame. `resolve` routes an inbound response to its waiter as the editor's `result` (absent or `null` is `Value::Null`) or its `JsonRpcError`. Requests and notifications are `NotAResponse`; ids never allocated, already answered or abandoned are `UnknownId`. Dropping a wait unregisters it ([SIDECAR-REQUEST-LIFETIME]). `sidecar::RequestId` rebuilds from its raw wire number with `From`, and `JsonRpcError` implements `Display` and `std::error::Error`. - **Position encoding** (`lspkit::vfs::PositionEncoding`): negotiates encoding at `initialize` per LSP 3.17 client capabilities; converts on every read; round-trips byte/char offsets correctly across multi-byte scalars and surrogate pairs. - **URI ↔ `PathBuf`** (`lspkit-server::uri`): handles `file://`, percent-decoding, Windows drive letters, UNC paths, and non-UTF-8 paths. - **[URI-AUTHORITY]** A URI's authority is its host, never a path segment. An empty or `localhost` host names a local path; any other host names a UNC path (`file://server/share/a.rs` ↔ `\\server\share\a.rs`) on Windows and is an error elsewhere. `uri_to_path` never returns a relative path. `path_to_uri` removes the extended-length prefixes `\\?\` and `\\?\UNC\` that `std::fs::canonicalize` adds. From 7a700d7aa9048d8de6e61213860a8b1bceb461db Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:53:00 +1100 Subject: [PATCH 07/39] Replace unwrap_or with explicit matches in Outbound and its tests --- crates/lspkit-server/src/outbound.rs | 13 ++++++++++--- crates/lspkit-server/tests/outbound.rs | 5 ++++- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/crates/lspkit-server/src/outbound.rs b/crates/lspkit-server/src/outbound.rs index 853b682..ca67b05 100644 --- a/crates/lspkit-server/src/outbound.rs +++ b/crates/lspkit-server/src/outbound.rs @@ -76,9 +76,7 @@ impl Outbound { let (Some(id), None) = (message.id, message.method) else { return Err(OutboundError::NotAResponse); }; - let answer = message - .error - .map_or_else(|| Ok(message.result.unwrap_or(Value::Null)), Err); + let answer = answer_of(message.error, message.result); let Some(raw) = correlated(&id) else { return Err(OutboundError::UnknownId(id)); }; @@ -107,6 +105,15 @@ fn wire_id(raw: u64) -> Result { .map_err(|_beyond_wire_numbers| OutboundError::IdsExhausted(raw)) } +/// The editor's answer: its error, its result, or `null` when it sent neither. +fn answer_of(error: Option, result: Option) -> OutboundResult { + match (error, result) { + (Some(error), _) => Err(error), + (None, Some(result)) => Ok(result), + (None, None) => Ok(Value::Null), + } +} + /// The correlator number behind a wire id this handle could have allocated. fn correlated(id: &RequestId) -> Option { match id { diff --git a/crates/lspkit-server/tests/outbound.rs b/crates/lspkit-server/tests/outbound.rs index 25fd2f1..cd6ed6e 100644 --- a/crates/lspkit-server/tests/outbound.rs +++ b/crates/lspkit-server/tests/outbound.rs @@ -43,7 +43,10 @@ async fn editor_receives(editor: &mut Wire, method: &str, params: &Value) -> Ste assert_eq!(request.jsonrpc, "2.0"); assert_eq!(request.method.as_deref(), Some(method)); // `"params": null` decodes as absent; both mean "no params" on the wire. - assert_eq!(request.params.as_ref().unwrap_or(&Value::Null), params); + match request.params.as_ref() { + Some(sent) => assert_eq!(sent, params), + None => assert_eq!(params, &Value::Null, "only null params are omitted"), + } let id = request.id.ok_or("a server request carries an id")?; assert!(matches!(id, RequestId::Number(raw) if raw > 0), "{id:?}"); Ok(id) From bfc2f8a18b09d9dfebd76a2587cf29ad851524d7 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 06:59:03 +1100 Subject: [PATCH 08/39] Drop unmaintained chrono and humantime: delete unused rmcp, format RFC 3339 with std RUSTSEC-2026-0543 (chrono) and RUSTSEC-2026-0542 (humantime). rmcp was never called and every release requires chrono; clock.rs replaces humantime with a civil-from-days formatter pinned by known-instant tests. --- Cargo.lock | 633 +----------------------- Cargo.toml | 3 - crates/lsp-profiler/Cargo.toml | 1 - crates/lsp-profiler/src/clock.rs | 100 ++++ crates/lsp-profiler/src/lib.rs | 1 + crates/lsp-profiler/src/session.rs | 17 +- crates/lspkit-server/Cargo.toml | 4 +- crates/lspkit-server/src/mcp/adapter.rs | 2 +- docs/specs/lspkit-spec.md | 9 +- 9 files changed, 114 insertions(+), 656 deletions(-) create mode 100644 crates/lsp-profiler/src/clock.rs diff --git a/Cargo.lock b/Cargo.lock index abe83d3..41b7b6c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -9,7 +9,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" dependencies = [ "cfg-if", - "getrandom 0.3.4", + "getrandom", "once_cell", "version_check", "zerocopy", @@ -30,21 +30,6 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" -[[package]] -name = "android_system_properties" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" -dependencies = [ - "libc", -] - -[[package]] -name = "anyhow" -version = "1.0.104" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" - [[package]] name = "arrayvec" version = "0.7.8" @@ -68,12 +53,6 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" -[[package]] -name = "base64" -version = "0.23.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" - [[package]] name = "bitflags" version = "1.3.2" @@ -86,27 +65,12 @@ version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" -[[package]] -name = "block-buffer" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa" -dependencies = [ - "hybrid-array", -] - [[package]] name = "boxcar" version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36f64beae40a84da1b4b26ff2761a5b895c12adc41dc25aaee1c4f2bbfe97a6e" -[[package]] -name = "bumpalo" -version = "3.20.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" - [[package]] name = "bytemuck" version = "1.25.2" @@ -135,39 +99,6 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" -[[package]] -name = "chrono" -version = "0.4.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" -dependencies = [ - "iana-time-zone", - "num-traits", - "serde", - "windows-link", -] - -[[package]] -name = "const-oid" -version = "0.10.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be95d4a884358a21a199689323c29e9256b4a1b315e22f183d155422041d3a9a" - -[[package]] -name = "core-foundation-sys" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" - -[[package]] -name = "cpufeatures" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" -dependencies = [ - "libc", -] - [[package]] name = "crossbeam-deque" version = "0.8.8" @@ -202,49 +133,6 @@ version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" -[[package]] -name = "crypto-common" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" -dependencies = [ - "hybrid-array", -] - -[[package]] -name = "darling" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec" -dependencies = [ - "darling_core", - "darling_macro", -] - -[[package]] -name = "darling_core" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff" -dependencies = [ - "ident_case", - "proc-macro2", - "quote", - "strsim", - "syn 3.0.9", -] - -[[package]] -name = "darling_macro" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785" -dependencies = [ - "darling_core", - "quote", - "syn 3.0.9", -] - [[package]] name = "dashmap" version = "6.2.1" @@ -259,17 +147,6 @@ dependencies = [ "parking_lot_core", ] -[[package]] -name = "digest" -version = "0.11.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" -dependencies = [ - "block-buffer", - "const-oid", - "crypto-common", -] - [[package]] name = "dispatch2" version = "0.3.1" @@ -291,12 +168,6 @@ dependencies = [ "syn 3.0.9", ] -[[package]] -name = "dyn-clone" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" - [[package]] name = "either" version = "1.19.0" @@ -340,12 +211,6 @@ dependencies = [ "bitflags 1.3.2", ] -[[package]] -name = "foldhash" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" - [[package]] name = "foldhash" version = "0.2.0" @@ -361,54 +226,12 @@ dependencies = [ "percent-encoding", ] -[[package]] -name = "futures" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" -dependencies = [ - "futures-channel", - "futures-core", - "futures-executor", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4" -dependencies = [ - "futures-core", - "futures-sink", -] - [[package]] name = "futures-core" version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" -[[package]] -name = "futures-executor" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-io" -version = "0.3.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" - [[package]] name = "futures-macro" version = "0.3.34" @@ -438,13 +261,9 @@ version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" dependencies = [ - "futures-channel", "futures-core", - "futures-io", "futures-macro", - "futures-sink", "futures-task", - "memchr", "pin-project-lite", "slab", ] @@ -457,21 +276,8 @@ checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", "libc", - "r-efi 5.3.0", - "wasip2", -] - -[[package]] -name = "getrandom" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" -dependencies = [ - "cfg-if", - "libc", - "r-efi 6.0.0", + "r-efi", "wasip2", - "wasip3", ] [[package]] @@ -480,15 +286,6 @@ version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" -[[package]] -name = "hashbrown" -version = "0.15.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" -dependencies = [ - "foldhash 0.1.5", -] - [[package]] name = "hashbrown" version = "0.17.1" @@ -497,7 +294,7 @@ checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" dependencies = [ "allocator-api2", "equivalent", - "foldhash 0.2.0", + "foldhash", ] [[package]] @@ -509,51 +306,6 @@ dependencies = [ "hashbrown 0.17.1", ] -[[package]] -name = "heck" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" - -[[package]] -name = "humantime" -version = "2.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15cdd26707701c53297e2fa6afb323d55fbc1d0810c3aec078ae3ef0424c3c15" - -[[package]] -name = "hybrid-array" -version = "0.4.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17" -dependencies = [ - "typenum", -] - -[[package]] -name = "iana-time-zone" -version = "0.1.65" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "log", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - [[package]] name = "icu_collections" version = "2.3.0" @@ -637,18 +389,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "id-arena" -version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" - -[[package]] -name = "ident_case" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" - [[package]] name = "idna" version = "1.1.0" @@ -678,8 +418,6 @@ checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", "hashbrown 0.17.1", - "serde", - "serde_core", ] [[package]] @@ -739,18 +477,6 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" -[[package]] -name = "js-sys" -version = "0.3.98" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08" -dependencies = [ - "cfg-if", - "futures-util", - "once_cell", - "wasm-bindgen", -] - [[package]] name = "kqueue" version = "1.1.1" @@ -777,12 +503,6 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "leb128fmt" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" - [[package]] name = "libc" version = "0.2.186" @@ -821,7 +541,6 @@ name = "lsp-profiler" version = "0.0.0-dev" dependencies = [ "async-trait", - "humantime", "inferno", "num-traits", "serde", @@ -895,7 +614,6 @@ dependencies = [ "lsp-types", "lspkit", "notify", - "rmcp", "salsa", "serde", "serde_json", @@ -1096,12 +814,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "pastey" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4" - [[package]] name = "percent-encoding" version = "2.3.2" @@ -1129,16 +841,6 @@ dependencies = [ "zerovec", ] -[[package]] -name = "prettyplease" -version = "0.2.37" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" -dependencies = [ - "proc-macro2", - "syn 2.0.117", -] - [[package]] name = "proc-macro2" version = "1.0.106" @@ -1172,12 +874,6 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" -[[package]] -name = "r-efi" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" - [[package]] name = "rayon" version = "1.12.0" @@ -1207,26 +903,6 @@ dependencies = [ "bitflags 2.11.1", ] -[[package]] -name = "ref-cast" -version = "1.0.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3" -dependencies = [ - "ref-cast-impl", -] - -[[package]] -name = "ref-cast-impl" -version = "1.0.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a" -dependencies = [ - "proc-macro2", - "quote", - "syn 3.0.9", -] - [[package]] name = "regex" version = "1.12.3" @@ -1265,44 +941,6 @@ dependencies = [ "bytemuck", ] -[[package]] -name = "rmcp" -version = "3.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5949e504d5ab9944a168259afc0c39ac0230627b6ec5367ace194c59bcbe163" -dependencies = [ - "base64", - "chrono", - "futures", - "indexmap", - "libc", - "pastey", - "pin-project-lite", - "rmcp-macros", - "schemars", - "serde", - "serde_json", - "sha2", - "thiserror", - "tokio", - "tokio-util", - "tracing", - "uuid", -] - -[[package]] -name = "rmcp-macros" -version = "3.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b98a686693ee91b665c6f89f182fca6e141c8a63dc113b11b38c1bf3491606b7" -dependencies = [ - "darling", - "proc-macro2", - "quote", - "serde_json", - "syn 3.0.9", -] - [[package]] name = "rmp" version = "0.8.15" @@ -1409,44 +1047,12 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "schemars" -version = "1.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab508826f74a77ca9d5aba6ff19b522583ee3eaf28a19384ff3d0e5835fadf6e" -dependencies = [ - "chrono", - "dyn-clone", - "ref-cast", - "schemars_derive", - "serde", - "serde_json", -] - -[[package]] -name = "schemars_derive" -version = "1.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1c3a92094fa7d61aa124645844facb6b554dfc797136d0f5fd1f890e2bffc69" -dependencies = [ - "proc-macro2", - "quote", - "serde_derive_internals", - "syn 3.0.9", -] - [[package]] name = "scopeguard" version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" -[[package]] -name = "semver" -version = "1.0.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" - [[package]] name = "serde" version = "1.0.229" @@ -1477,24 +1083,13 @@ dependencies = [ "syn 3.0.9", ] -[[package]] -name = "serde_derive_internals" -version = "0.30.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f852137cce035d6a4df67ccce505ff6b3e9fd3a10e3e52b24dc71e650bb1a9bd" -dependencies = [ - "proc-macro2", - "quote", - "syn 3.0.9", -] - [[package]] name = "serde_json" version = "1.0.154" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" dependencies = [ - "foldhash 0.2.0", + "foldhash", "indexmap", "itoa", "memchr", @@ -1523,17 +1118,6 @@ dependencies = [ "serde_core", ] -[[package]] -name = "sha2" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19" -dependencies = [ - "cfg-if", - "cpufeatures", - "digest", -] - [[package]] name = "sharded-slab" version = "0.1.7" @@ -1611,12 +1195,6 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520" -[[package]] -name = "strsim" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" - [[package]] name = "syn" version = "2.0.117" @@ -1672,7 +1250,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.4", + "getrandom", "once_cell", "rustix", "windows-sys", @@ -1912,24 +1490,12 @@ version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" -[[package]] -name = "typenum" -version = "1.20.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" - [[package]] name = "unicode-ident" version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" -[[package]] -name = "unicode-xid" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" - [[package]] name = "url" version = "2.5.8" @@ -1948,17 +1514,6 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" -[[package]] -name = "uuid" -version = "1.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606" -dependencies = [ - "getrandom 0.4.2", - "js-sys", - "wasm-bindgen", -] - [[package]] name = "valuable" version = "0.1.1" @@ -1993,95 +1548,7 @@ version = "1.0.3+wasi-0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" dependencies = [ - "wit-bindgen 0.57.1", -] - -[[package]] -name = "wasip3" -version = "0.4.0+wasi-0.3.0-rc-2026-01-06" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" -dependencies = [ - "wit-bindgen 0.51.0", -] - -[[package]] -name = "wasm-bindgen" -version = "0.2.121" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790" -dependencies = [ - "cfg-if", - "once_cell", - "rustversion", - "wasm-bindgen-macro", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.121" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.121" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2" -dependencies = [ - "bumpalo", - "proc-macro2", - "quote", - "syn 2.0.117", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.121" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "wasm-encoder" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" -dependencies = [ - "leb128fmt", - "wasmparser", -] - -[[package]] -name = "wasm-metadata" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" -dependencies = [ - "anyhow", - "indexmap", - "wasm-encoder", - "wasmparser", -] - -[[package]] -name = "wasmparser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" -dependencies = [ - "bitflags 2.11.1", - "hashbrown 0.15.5", - "indexmap", - "semver", + "wit-bindgen", ] [[package]] @@ -2240,100 +1707,12 @@ version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1" -[[package]] -name = "wit-bindgen" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" -dependencies = [ - "wit-bindgen-rust-macro", -] - [[package]] name = "wit-bindgen" version = "0.57.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" -[[package]] -name = "wit-bindgen-core" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" -dependencies = [ - "anyhow", - "heck", - "wit-parser", -] - -[[package]] -name = "wit-bindgen-rust" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" -dependencies = [ - "anyhow", - "heck", - "indexmap", - "prettyplease", - "syn 2.0.117", - "wasm-metadata", - "wit-bindgen-core", - "wit-component", -] - -[[package]] -name = "wit-bindgen-rust-macro" -version = "0.51.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" -dependencies = [ - "anyhow", - "prettyplease", - "proc-macro2", - "quote", - "syn 2.0.117", - "wit-bindgen-core", - "wit-bindgen-rust", -] - -[[package]] -name = "wit-component" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" -dependencies = [ - "anyhow", - "bitflags 2.11.1", - "indexmap", - "log", - "serde", - "serde_derive", - "serde_json", - "wasm-encoder", - "wasm-metadata", - "wasmparser", - "wit-parser", -] - -[[package]] -name = "wit-parser" -version = "0.244.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" -dependencies = [ - "anyhow", - "id-arena", - "indexmap", - "log", - "semver", - "serde", - "serde_derive", - "serde_json", - "unicode-xid", - "wasmparser", -] - [[package]] name = "writeable" version = "0.6.4" diff --git a/Cargo.toml b/Cargo.toml index da7af9a..b516149 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -124,8 +124,6 @@ rmp-serde = "1" # LSP protocol types (maintained; we ship our own server loop) lsp-types = "0.97" -# MCP SDK -rmcp = "3.10" # Document / state dashmap = "6" @@ -143,7 +141,6 @@ tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] } # Profiler ([PROF-INVARIANTS]: only the core and runtime crates use these) -humantime = "2" inferno = { version = "0.12", default-features = false } num-traits = "0.2" sysinfo = { version = "0.39.3", default-features = false, features = ["system", "user"] } diff --git a/crates/lsp-profiler/Cargo.toml b/crates/lsp-profiler/Cargo.toml index b711405..95f806b 100644 --- a/crates/lsp-profiler/Cargo.toml +++ b/crates/lsp-profiler/Cargo.toml @@ -23,7 +23,6 @@ workspace = true [dependencies] async-trait.workspace = true -humantime.workspace = true inferno.workspace = true num-traits.workspace = true serde.workspace = true diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs new file mode 100644 index 0000000..bef6b63 --- /dev/null +++ b/crates/lsp-profiler/src/clock.rs @@ -0,0 +1,100 @@ +//! RFC 3339 UTC timestamps from [`SystemTime`] with std only. [PROF-CPU-SESSIONS] +//! +//! Replaces `humantime`, which RUSTSEC-2026-0542 marks unmaintained. + +use std::time::{SystemTime, UNIX_EPOCH}; + +/// The current time as RFC 3339 UTC, to the second. +#[must_use] +pub fn rfc3339_now() -> String { + rfc3339(SystemTime::now()) +} + +/// Seconds in one civil day. +const DAY_SECS: i128 = 86_400; +/// Days in one 400-year Gregorian era. +const ERA_DAYS: i128 = 146_097; +/// Days from 0000-03-01 to 1970-01-01. +const EPOCH_SHIFT: i128 = 719_468; + +/// `time` as RFC 3339 UTC, truncated (floored) to the second. +#[must_use] +pub fn rfc3339(time: SystemTime) -> String { + let secs = epoch_seconds(time); + let (year, month, day) = civil(secs.div_euclid(DAY_SECS)); + let clock = secs.rem_euclid(DAY_SECS); + let (hour, minute, second) = ( + clock.div_euclid(3600), + clock.rem_euclid(3600).div_euclid(60), + clock.rem_euclid(60), + ); + format!("{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}Z") +} + +/// Whole seconds since the Unix epoch, floored, negative before it. +fn epoch_seconds(time: SystemTime) -> i128 { + match time.duration_since(UNIX_EPOCH) { + Ok(after) => i128::from(after.as_secs()), + Err(before) => { + let gap = before.duration(); + -i128::from(gap.as_secs()) - i128::from(gap.subsec_nanos() > 0) + } + } +} + +/// The proleptic Gregorian (year, month, day) of `days` since 1970-01-01. +fn civil(days: i128) -> (i128, i128, i128) { + let shifted = days + EPOCH_SHIFT; + let era = shifted.div_euclid(ERA_DAYS); + let day_of_era = shifted - era * ERA_DAYS; + let year_of_era = (day_of_era - day_of_era.div_euclid(1460) + day_of_era.div_euclid(36_524) + - day_of_era.div_euclid(ERA_DAYS - 1)) + .div_euclid(365); + let day_of_year = + day_of_era - (365 * year_of_era + year_of_era.div_euclid(4) - year_of_era.div_euclid(100)); + let march_month = (5 * day_of_year + 2).div_euclid(153); + let day = day_of_year - (153 * march_month + 2).div_euclid(5) + 1; + let month = if march_month < 10 { + march_month + 3 + } else { + march_month - 9 + }; + (year_of_era + era * 400 + i128::from(month <= 2), month, day) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::time::Duration; + + /// Seconds after the epoch and the timestamp they must format as. + const KNOWN: [(u64, &str); 6] = [ + (0, "1970-01-01T00:00:00Z"), + (951_782_400, "2000-02-29T00:00:00Z"), + (951_868_799, "2000-02-29T23:59:59Z"), + (1_700_000_000, "2023-11-14T22:13:20Z"), + (4_107_542_400, "2100-03-01T00:00:00Z"), + (253_402_300_799, "9999-12-31T23:59:59Z"), + ]; + + #[test] + fn known_instants_format_as_rfc3339_utc_seconds() { + for (secs, want) in KNOWN { + let exact = UNIX_EPOCH + Duration::from_secs(secs); + assert_eq!(rfc3339(exact), want, "{secs}s"); + let later = exact + Duration::from_nanos(999_999_999); + assert_eq!(rfc3339(later), want, "{secs}s truncates sub-seconds"); + } + let before = UNIX_EPOCH - Duration::from_millis(1); + assert_eq!( + rfc3339(before), + "1969-12-31T23:59:59Z", + "floors before the epoch" + ); + let early = UNIX_EPOCH - Duration::from_secs(2_208_988_800); + assert_eq!(rfc3339(early), "1900-01-01T00:00:00Z"); + let now = rfc3339_now(); + assert_eq!(now.len(), "2026-10-14T00:00:00Z".len(), "{now}"); + assert!(now.ends_with('Z') && now.get(10..11) == Some("T"), "{now}"); + } +} diff --git a/crates/lsp-profiler/src/lib.rs b/crates/lsp-profiler/src/lib.rs index 602c531..fd54a71 100644 --- a/crates/lsp-profiler/src/lib.rs +++ b/crates/lsp-profiler/src/lib.rs @@ -11,6 +11,7 @@ //! The wire types in [`wire`] are generated from `docs/models/profiler.td`. pub mod aggregate; +pub mod clock; pub mod commands; pub mod cooperative; pub mod diagnostics; diff --git a/crates/lsp-profiler/src/session.rs b/crates/lsp-profiler/src/session.rs index 1a5485f..b1d2555 100644 --- a/crates/lsp-profiler/src/session.rs +++ b/crates/lsp-profiler/src/session.rs @@ -12,6 +12,7 @@ use tokio::sync::Mutex; use tracing::{debug, info}; use crate::aggregate::{saturating_i64, HotspotConfig, ProfileData}; +use crate::clock::rfc3339_now; use crate::error::ProfilerError; use crate::runtime::Runtime; use crate::sampler::{SampleBatch, SamplerHandle, SamplerStop}; @@ -376,12 +377,6 @@ pub fn mint_id(prefix: &str, sequence: u64) -> String { ) } -/// The current time as RFC 3339 UTC, to the second. -#[must_use] -pub fn rfc3339_now() -> String { - humantime::format_rfc3339_seconds(SystemTime::now()).to_string() -} - /// The function the program spends its own time in: the most self samples, /// ties broken by name. Ranked by inclusive samples, the root of every whole /// stack would always be the hottest [PROF-CPU-PROGRESS]. @@ -400,16 +395,6 @@ fn hottest_by_self(functions: &[HotFunction]) -> Option { mod tests { use super::*; - #[test] - fn rfc3339_now_is_utc_to_the_second() { - let now = rfc3339_now(); - assert_eq!(now.len(), "2026-10-14T00:00:00Z".len(), "{now}"); - assert!( - now.ends_with('Z') && now.as_bytes().get(10) == Some(&b'T'), - "{now}" - ); - } - fn hot(name: &str, samples: i64, self_samples: i64) -> HotFunction { HotFunction { name: name.to_owned(), diff --git a/crates/lspkit-server/Cargo.toml b/crates/lspkit-server/Cargo.toml index 7fe6ac8..a8c5cdf 100644 --- a/crates/lspkit-server/Cargo.toml +++ b/crates/lspkit-server/Cargo.toml @@ -32,12 +32,10 @@ tokio.workspace = true tokio-util.workspace = true tracing.workspace = true -# Optional: the MCP SDK stays out of LSP-only consumers. [CRATE-LAYOUT-FEATURES] -rmcp = { workspace = true, optional = true } salsa = { version = "0.28.5", optional = true } [features] -mcp = ["dep:rmcp"] +mcp = [] pull = ["dep:salsa"] [dev-dependencies] diff --git a/crates/lspkit-server/src/mcp/adapter.rs b/crates/lspkit-server/src/mcp/adapter.rs index f55f3bc..2c92098 100644 --- a/crates/lspkit-server/src/mcp/adapter.rs +++ b/crates/lspkit-server/src/mcp/adapter.rs @@ -1,6 +1,6 @@ //! Adapter that mounts an [`lspkit::EngineApi`] implementation as an MCP server. //! -//! The adapter does not leak `rmcp::*` types into its public surface; every +//! The adapter exposes no MCP SDK types in its public surface; every //! request/response shape is wrapped behind newtypes defined in this crate. use std::sync::Arc; diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 8051b3f..82aa1cf 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -11,7 +11,7 @@ These are non-negotiable. Any patch violating one is illegal. - **Generic only.** Toolkit code, docs, READMEs, comments, and examples MUST NOT reference any specific consumer, domain, language ecosystem, or product. A grep for known consumer names returns zero hits in `crates/` and `README.md`. - **No language-specific backend code.** No Roslyn, FCS, Pyright, Ruff, tree-sitter grammar bundling, nor any other language ecosystem glue lives in any crate. `lspkit::sidecar` is pure transport — its public surface MUST NOT name any backend technology. - **Maintained bedrock or self-owned.** Toolkit MUST NOT depend on unmaintained crates for core protocol handling. `tower-lsp` is forbidden (last release 2023). The toolkit depends on `lsp-types` (maintained) and ships its own JSON-RPC server loop inside `lspkit-server`. -- **Third-party LSP/MCP types stay hidden.** No `rmcp::*` or `lsp_types::*` request/response type appears in a `pub` signature of `lspkit` or `lspkit-server`. Newtype wrappers are required at every boundary. +- **Third-party LSP/MCP types stay hidden.** No MCP SDK or `lsp_types::*` request/response type appears in a `pub` signature of `lspkit` or `lspkit-server`. Newtype wrappers are required at every boundary. - **No wire-format coupling.** The toolkit ships no typeDiagram-generated types. Consumers define their own wire schemas case-by-case. - **Locks never span `.await`.** `lspkit::vfs` MUST scope all `DashMap` and `Mutex` guards inside synchronous blocks; methods MUST NOT return guards. @@ -22,7 +22,7 @@ Four published crates. The split is locked. | Crate | Public surface (intent) | |---|---| | **lspkit** | Façade. Exposes `EngineApi` trait + `Generation`, `Snapshot`, `GenerationEvent`, `Cause`, `RescanScope`, `RescanTicket` types. Feature `tracing-setup` exposes a stdio-safe `tracing-subscriber` builder. `prelude` module re-exports the headline items. Modules `config` (layered TOML loader), `vfs` (concurrent open-document store), `sidecar` (framed IPC transport) and `treesitter` (parse cache, behind the `treesitter` feature). | -| **lspkit-server** | LSP server scaffolding built on `lsp-types`: Content-Length framing, JSON-RPC request/response/notification dispatcher, capability builder, URI ↔ `PathBuf` helpers, workspace-folders abstraction, diagnostics fan-out bus, progress sink, cancellation plumbing. Consumers register handlers; the crate routes them to an `EngineApi` + VFS pair. Modules `live` (file-watcher → debouncer → single-flight scheduler → session lifecycle) and `mcp` (`rmcp` adapter, behind the `mcp` feature). | +| **lspkit-server** | LSP server scaffolding built on `lsp-types`: Content-Length framing, JSON-RPC request/response/notification dispatcher, capability builder, URI ↔ `PathBuf` helpers, workspace-folders abstraction, diagnostics fan-out bus, progress sink, cancellation plumbing. Consumers register handlers; the crate routes them to an `EngineApi` + VFS pair. Modules `live` (file-watcher → debouncer → single-flight scheduler → session lifecycle) and `mcp` (tool adapter, behind the `mcp` feature). | | **lsp-profiler** | Language-neutral CPU and memory profiler core: sessions, hotspots, flame graphs, speedscope/V8 exports, heap snapshots, leak scoring, one JSON-RPC protocol. Spec: [LSP-PROFILER-SPEC.md](LSP-PROFILER-SPEC.md). | | **lsp-profiler-dotnet** | The profiler's .NET runtime: EventPipe CPU sampling and heap snapshots through the engine in `dotnet/`. | @@ -33,7 +33,7 @@ Implementation tracker: [docs/plans/crate-consolidation-plan.md](../plans/crate- - **[CRATE-LAYOUT]** The workspace publishes exactly four crates in dependency order: `lsp-profiler`, `lsp-profiler-dotnet`, `lspkit`, `lspkit-server`. `lsp-profiler-python` is parked: it stays in the repo, excluded from the workspace and unpublished. - **[CRATE-LAYOUT-LAYERS]** An L1 crate depends only on its own tree's L0 crate. An L0 crate has no internal dependencies. - **[CRATE-LAYOUT-MODULES]** Each absorbed crate becomes a top-level module with the same name: `lspkit::config`, `lspkit::vfs`, `lspkit::treesitter`, `lspkit::sidecar`, `lspkit_server::live`, `lspkit_server::mcp`. Each module keeps its absorbed crate's coverage floor as a `::` key in `coverage-thresholds.json`. -- **[CRATE-LAYOUT-FEATURES]** Heavy dependency cones are opt-in cargo features, all default off: `lspkit-server/mcp` (`rmcp`), `lspkit-server/pull` (`salsa`), `lspkit/treesitter` (`tree-sitter`, a C runtime) and `lspkit/tracing-setup` (`tracing-subscriber`). `lspkit::sidecar` is always on; its dependencies are already in `lspkit`'s core. +- **[CRATE-LAYOUT-FEATURES]** Heavy dependency cones are opt-in cargo features, all default off: `lspkit-server/mcp` (the tool adapter; it takes no MCP SDK, since every `rmcp` release pulls unmaintained `chrono`, RUSTSEC-2026-0543), `lspkit-server/pull` (`salsa`), `lspkit/treesitter` (`tree-sitter`, a C runtime) and `lspkit/tracing-setup` (`tracing-subscriber`). `lspkit::sidecar` is always on; its dependencies are already in `lspkit`'s core. - **[CRATE-LAYOUT-HELPER]** `lsp-profiler-helper` is a `[[bin]]` target of `lsp-profiler-python` (`src/bin/lsp-profiler-helper/`), not a crate. - **[CRATE-RETIRE]** The six absorbed `lspkit-*` names are already on crates.io at 0.0.1. After the consolidated release ships, delete `lspkit-config`, `lspkit-treesitter`, `lspkit-sidecar`, `lspkit-mcp` and `lspkit-live` on crates.io, and yank `lspkit-vfs` 0.0.1 with a deprecation README pointing to `lspkit::vfs`. @@ -104,7 +104,6 @@ pub trait EngineApi: Send + Sync + 'static { - `tokio` 1.x, `tracing` + `tracing-subscriber`, `serde` + `serde_derive`, `async-trait`. - `lsp-types` (current major). -- `rmcp` (current minor, pinned). - `notify` 7.x, `ropey` 1.x, `dashmap` 6.x, `tokio-util` (for `CancellationToken`). - `rmp-serde` available as the default wire format for `lspkit::sidecar`; transport is generic over `serde`. - **No `tower-lsp`.** Ever. @@ -157,7 +156,7 @@ A patch is acceptable iff: 3. `cargo doc --workspace --no-deps` produces docs with zero `missing_docs` warnings. 4. `cargo clippy --workspace -- -D warnings` is clean. 5. `rg -i -e 'basilisk' -e 'deslop' -e 'sharplsp' -e 'lql' -e 'tower-lsp' -e 'roslyn' -e 'pyright' crates/` returns **zero hits**. The crates stay generic; the README and website name consumers only as showcased examples. -6. `grep -R 'tower_lsp\|rmcp::' crates/*/src/lib.rs` returns **zero hits** in `pub` signatures (manual review against the rule). +6. `grep -R 'tower_lsp' crates/*/src/lib.rs` returns **zero hits** in `pub` signatures (manual review against the rule). 7. The `EngineApi` trait skeleton compiles and is exercised by a smoke test that constructs a no-op implementation and calls each method. 8. Each of the four source repos has a "Migration to `lspkit`" section in its AI-guidance file. 9. **[REL-OIDC]** `.github/workflows/release.yml` publishes crates.io (`rust-lang/crates-io-auth-action`) and npm (`--provenance`) under `environment: release`, references no registry token secret, and pins every `uses:` to a 40-char SHA. From f538d5b99cf4662404fac61f15a261a2bdc7a648 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:02:17 +1100 Subject: [PATCH 09/39] Delete the empty mcp feature and name the civil-calendar constants With rmcp gone the feature gated no dependency; the mcp module is always on. --- crates/lsp-profiler/src/clock.rs | 52 +++++++++++++++++------ crates/lspkit-server/Cargo.toml | 1 - crates/lspkit-server/src/lib.rs | 1 - crates/lspkit-server/tests/mcp_adapter.rs | 2 - crates/lspkit-server/tests/mcp_tools.rs | 2 - docs/plans/crate-consolidation-plan.md | 2 +- docs/specs/lspkit-spec.md | 4 +- website/src/blog/one-engine.md | 4 +- website/src/docs/getting-started.md | 2 +- 9 files changed, 45 insertions(+), 25 deletions(-) diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs index bef6b63..af44608 100644 --- a/crates/lsp-profiler/src/clock.rs +++ b/crates/lsp-profiler/src/clock.rs @@ -16,6 +16,26 @@ const DAY_SECS: i128 = 86_400; const ERA_DAYS: i128 = 146_097; /// Days from 0000-03-01 to 1970-01-01. const EPOCH_SHIFT: i128 = 719_468; +/// Seconds in one hour. +const HOUR_SECS: i128 = 3_600; +/// Seconds in one minute. +const MINUTE_SECS: i128 = 60; +/// Days in a common year. +const YEAR_DAYS: i128 = 365; +/// Days in four years, one of them leap. +const LEAP_CYCLE_DAYS: i128 = 1_460; +/// Days in a century that skips its leap day. +const CENTURY_DAYS: i128 = 36_524; +/// Years in a Gregorian era. +const ERA_YEARS: i128 = 400; +/// Hinnant's month-from-day-of-year line: month = (5·doy + 2) / 153. +const MONTH_SLOPE: (i128, i128, i128) = (5, 2, 153); +/// March-based months before the year rolls into January. +const MARCH_MONTHS_TO_YEAR_END: i128 = 10; +/// Calendar months in a year. +const YEAR_MONTHS: i128 = 12; +/// March as a calendar month number. +const MARCH: i128 = 3; /// `time` as RFC 3339 UTC, truncated (floored) to the second. #[must_use] @@ -24,9 +44,9 @@ pub fn rfc3339(time: SystemTime) -> String { let (year, month, day) = civil(secs.div_euclid(DAY_SECS)); let clock = secs.rem_euclid(DAY_SECS); let (hour, minute, second) = ( - clock.div_euclid(3600), - clock.rem_euclid(3600).div_euclid(60), - clock.rem_euclid(60), + clock.div_euclid(HOUR_SECS), + clock.rem_euclid(HOUR_SECS).div_euclid(MINUTE_SECS), + clock.rem_euclid(MINUTE_SECS), ); format!("{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}Z") } @@ -47,19 +67,25 @@ fn civil(days: i128) -> (i128, i128, i128) { let shifted = days + EPOCH_SHIFT; let era = shifted.div_euclid(ERA_DAYS); let day_of_era = shifted - era * ERA_DAYS; - let year_of_era = (day_of_era - day_of_era.div_euclid(1460) + day_of_era.div_euclid(36_524) + let year_of_era = (day_of_era - day_of_era.div_euclid(LEAP_CYCLE_DAYS) + + day_of_era.div_euclid(CENTURY_DAYS) - day_of_era.div_euclid(ERA_DAYS - 1)) - .div_euclid(365); - let day_of_year = - day_of_era - (365 * year_of_era + year_of_era.div_euclid(4) - year_of_era.div_euclid(100)); - let march_month = (5 * day_of_year + 2).div_euclid(153); - let day = day_of_year - (153 * march_month + 2).div_euclid(5) + 1; - let month = if march_month < 10 { - march_month + 3 + .div_euclid(YEAR_DAYS); + let day_of_year = day_of_era + - (YEAR_DAYS * year_of_era + year_of_era.div_euclid(4) - year_of_era.div_euclid(100)); + let (slope, offset, span) = MONTH_SLOPE; + let march_month = (slope * day_of_year + offset).div_euclid(span); + let day = day_of_year - (span * march_month + offset).div_euclid(slope) + 1; + let month = if march_month < MARCH_MONTHS_TO_YEAR_END { + march_month + MARCH } else { - march_month - 9 + march_month + MARCH - YEAR_MONTHS }; - (year_of_era + era * 400 + i128::from(month <= 2), month, day) + ( + year_of_era + era * ERA_YEARS + i128::from(month < MARCH), + month, + day, + ) } #[cfg(test)] diff --git a/crates/lspkit-server/Cargo.toml b/crates/lspkit-server/Cargo.toml index a8c5cdf..0c5f459 100644 --- a/crates/lspkit-server/Cargo.toml +++ b/crates/lspkit-server/Cargo.toml @@ -35,7 +35,6 @@ tracing.workspace = true salsa = { version = "0.28.5", optional = true } [features] -mcp = [] pull = ["dep:salsa"] [dev-dependencies] diff --git a/crates/lspkit-server/src/lib.rs b/crates/lspkit-server/src/lib.rs index b2bbcff..cc305b0 100644 --- a/crates/lspkit-server/src/lib.rs +++ b/crates/lspkit-server/src/lib.rs @@ -21,7 +21,6 @@ pub mod diagnostics; pub mod dispatch; pub mod jsonrpc; pub mod live; -#[cfg(feature = "mcp")] pub mod mcp; pub mod outbound; pub mod progress; diff --git a/crates/lspkit-server/tests/mcp_adapter.rs b/crates/lspkit-server/tests/mcp_adapter.rs index 092fcec..0773310 100644 --- a/crates/lspkit-server/tests/mcp_adapter.rs +++ b/crates/lspkit-server/tests/mcp_adapter.rs @@ -1,7 +1,5 @@ //! Coverage for [`lspkit_server::mcp::Adapter`] construction, dispatch, and errors. -#![cfg(feature = "mcp")] - #[path = "mcp_common/mod.rs"] mod common; diff --git a/crates/lspkit-server/tests/mcp_tools.rs b/crates/lspkit-server/tests/mcp_tools.rs index 1d64deb..8f0e1aa 100644 --- a/crates/lspkit-server/tests/mcp_tools.rs +++ b/crates/lspkit-server/tests/mcp_tools.rs @@ -1,7 +1,5 @@ //! Coverage for `ToolDescription` and `ToolRegistry`. -#![cfg(feature = "mcp")] - use lspkit_server::mcp::{ToolDescription, ToolRegistry}; use serde_json::json; diff --git a/docs/plans/crate-consolidation-plan.md b/docs/plans/crate-consolidation-plan.md index 0f29112..27e7383 100644 --- a/docs/plans/crate-consolidation-plan.md +++ b/docs/plans/crate-consolidation-plan.md @@ -21,7 +21,7 @@ graph TD - **`[CRATE-LAYOUT-LAYERS]`** An L1 crate depends only on its own tree's L0 crate. An L0 crate has no internal dependencies. - **`[CRATE-LAYOUT-MODULES]`** Each absorbed crate becomes a top-level module with the same name: `lspkit::config`, `lspkit::vfs`, `lspkit::treesitter`, `lspkit::sidecar`, `lspkit_server::live`, `lspkit_server::mcp`. -- **`[CRATE-LAYOUT-FEATURES]`** `lspkit-server`'s `mcp` cargo feature (default off) keeps the MCP dependency out of LSP-only consumers. `treesitter` and `sidecar` become features of `lspkit` only if their dependencies are heavy. +- **`[CRATE-LAYOUT-FEATURES]`** `lspkit-server`'s `mcp` module is always on: it has no dependencies of its own since the unused `rmcp` SDK was deleted. `treesitter` and `sidecar` become features of `lspkit` only if their dependencies are heavy. - **`[CRATE-LAYOUT-HELPER]`** `lsp-profiler-helper` becomes a `[[bin]]` target of `lsp-profiler-python`. ## Retiring published names `[CRATE-RETIRE]` diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 82aa1cf..e961c77 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -22,7 +22,7 @@ Four published crates. The split is locked. | Crate | Public surface (intent) | |---|---| | **lspkit** | Façade. Exposes `EngineApi` trait + `Generation`, `Snapshot`, `GenerationEvent`, `Cause`, `RescanScope`, `RescanTicket` types. Feature `tracing-setup` exposes a stdio-safe `tracing-subscriber` builder. `prelude` module re-exports the headline items. Modules `config` (layered TOML loader), `vfs` (concurrent open-document store), `sidecar` (framed IPC transport) and `treesitter` (parse cache, behind the `treesitter` feature). | -| **lspkit-server** | LSP server scaffolding built on `lsp-types`: Content-Length framing, JSON-RPC request/response/notification dispatcher, capability builder, URI ↔ `PathBuf` helpers, workspace-folders abstraction, diagnostics fan-out bus, progress sink, cancellation plumbing. Consumers register handlers; the crate routes them to an `EngineApi` + VFS pair. Modules `live` (file-watcher → debouncer → single-flight scheduler → session lifecycle) and `mcp` (tool adapter, behind the `mcp` feature). | +| **lspkit-server** | LSP server scaffolding built on `lsp-types`: Content-Length framing, JSON-RPC request/response/notification dispatcher, capability builder, URI ↔ `PathBuf` helpers, workspace-folders abstraction, diagnostics fan-out bus, progress sink, cancellation plumbing. Consumers register handlers; the crate routes them to an `EngineApi` + VFS pair. Modules `live` (file-watcher → debouncer → single-flight scheduler → session lifecycle) and `mcp` (tool adapter, always on; it takes no MCP SDK, since every `rmcp` release pulls unmaintained `chrono`, RUSTSEC-2026-0543). | | **lsp-profiler** | Language-neutral CPU and memory profiler core: sessions, hotspots, flame graphs, speedscope/V8 exports, heap snapshots, leak scoring, one JSON-RPC protocol. Spec: [LSP-PROFILER-SPEC.md](LSP-PROFILER-SPEC.md). | | **lsp-profiler-dotnet** | The profiler's .NET runtime: EventPipe CPU sampling and heap snapshots through the engine in `dotnet/`. | @@ -33,7 +33,7 @@ Implementation tracker: [docs/plans/crate-consolidation-plan.md](../plans/crate- - **[CRATE-LAYOUT]** The workspace publishes exactly four crates in dependency order: `lsp-profiler`, `lsp-profiler-dotnet`, `lspkit`, `lspkit-server`. `lsp-profiler-python` is parked: it stays in the repo, excluded from the workspace and unpublished. - **[CRATE-LAYOUT-LAYERS]** An L1 crate depends only on its own tree's L0 crate. An L0 crate has no internal dependencies. - **[CRATE-LAYOUT-MODULES]** Each absorbed crate becomes a top-level module with the same name: `lspkit::config`, `lspkit::vfs`, `lspkit::treesitter`, `lspkit::sidecar`, `lspkit_server::live`, `lspkit_server::mcp`. Each module keeps its absorbed crate's coverage floor as a `::` key in `coverage-thresholds.json`. -- **[CRATE-LAYOUT-FEATURES]** Heavy dependency cones are opt-in cargo features, all default off: `lspkit-server/mcp` (the tool adapter; it takes no MCP SDK, since every `rmcp` release pulls unmaintained `chrono`, RUSTSEC-2026-0543), `lspkit-server/pull` (`salsa`), `lspkit/treesitter` (`tree-sitter`, a C runtime) and `lspkit/tracing-setup` (`tracing-subscriber`). `lspkit::sidecar` is always on; its dependencies are already in `lspkit`'s core. +- **[CRATE-LAYOUT-FEATURES]** Heavy dependency cones are opt-in cargo features, all default off: `lspkit-server/pull` (`salsa`), `lspkit/treesitter` (`tree-sitter`, a C runtime) and `lspkit/tracing-setup` (`tracing-subscriber`). `lspkit::sidecar` is always on; its dependencies are already in `lspkit`'s core. - **[CRATE-LAYOUT-HELPER]** `lsp-profiler-helper` is a `[[bin]]` target of `lsp-profiler-python` (`src/bin/lsp-profiler-helper/`), not a crate. - **[CRATE-RETIRE]** The six absorbed `lspkit-*` names are already on crates.io at 0.0.1. After the consolidated release ships, delete `lspkit-config`, `lspkit-treesitter`, `lspkit-sidecar`, `lspkit-mcp` and `lspkit-live` on crates.io, and yank `lspkit-vfs` 0.0.1 with a deprecation README pointing to `lspkit::vfs`. diff --git a/website/src/blog/one-engine.md b/website/src/blog/one-engine.md index aba8f01..5589b80 100644 --- a/website/src/blog/one-engine.md +++ b/website/src/blog/one-engine.md @@ -21,10 +21,10 @@ The obvious build is a language server with its own caches, then an MCP server b ## One engine, two surfaces -lspkit puts analysis behind one Rust trait, `EngineApi`. The `lspkit-server` crate serves it over LSP to VS Code; its `mcp` feature serves the same engine over MCP to Claude Code, Cursor or Codex. +lspkit puts analysis behind one Rust trait, `EngineApi`. The `lspkit-server` crate serves it over LSP to VS Code; its `mcp` module serves the same engine over MCP to Claude Code, Cursor or Codex. ```sh -cargo add lspkit lspkit-server --features lspkit-server/mcp +cargo add lspkit lspkit-server ``` Every report carries a **generation** number, so the editor and the agent can both tell which state of the workspace produced an answer. Cancellation and progress live at the same boundary, so a slow query from the agent never blocks the editor. diff --git a/website/src/docs/getting-started.md b/website/src/docs/getting-started.md index 8b77cb5..14130e5 100644 --- a/website/src/docs/getting-started.md +++ b/website/src/docs/getting-started.md @@ -21,7 +21,7 @@ Turn on the features you need: ```sh cargo add lspkit --features treesitter -cargo add lspkit-server --features mcp +cargo add lspkit-server ``` ## Implement the engine From 2d6c26cfc9f2bb519af778faf00e53e3f27e291e Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:04:40 +1100 Subject: [PATCH 10/39] Pin century leap rules in the RFC 3339 clock: 1600, 1900, 2100 and 2400 edges --- crates/lsp-profiler/src/clock.rs | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs index af44608..3721c72 100644 --- a/crates/lsp-profiler/src/clock.rs +++ b/crates/lsp-profiler/src/clock.rs @@ -94,15 +94,33 @@ mod tests { use std::time::Duration; /// Seconds after the epoch and the timestamp they must format as. - const KNOWN: [(u64, &str); 6] = [ + const KNOWN: [(u64, &str); 8] = [ (0, "1970-01-01T00:00:00Z"), (951_782_400, "2000-02-29T00:00:00Z"), (951_868_799, "2000-02-29T23:59:59Z"), (1_700_000_000, "2023-11-14T22:13:20Z"), + (4_107_542_399, "2100-02-28T23:59:59Z"), (4_107_542_400, "2100-03-01T00:00:00Z"), + (13_574_606_400, "2400-02-29T12:00:00Z"), (253_402_300_799, "9999-12-31T23:59:59Z"), ]; + /// Seconds before the epoch and the timestamp they must format as. + const BEFORE_EPOCH: [(u64, &str); 4] = [ + (2_208_988_800, "1900-01-01T00:00:00Z"), + (2_203_891_201, "1900-02-28T23:59:59Z"), + (2_203_891_200, "1900-03-01T00:00:00Z"), + (11_670_998_400, "1600-02-29T00:00:00Z"), + ]; + + #[test] + fn century_leap_rules_hold_before_the_epoch() { + for (secs, want) in BEFORE_EPOCH { + let instant = UNIX_EPOCH - Duration::from_secs(secs); + assert_eq!(rfc3339(instant), want, "-{secs}s"); + } + } + #[test] fn known_instants_format_as_rfc3339_utc_seconds() { for (secs, want) in KNOWN { @@ -117,8 +135,6 @@ mod tests { "1969-12-31T23:59:59Z", "floors before the epoch" ); - let early = UNIX_EPOCH - Duration::from_secs(2_208_988_800); - assert_eq!(rfc3339(early), "1900-01-01T00:00:00Z"); let now = rfc3339_now(); assert_eq!(now.len(), "2026-10-14T00:00:00Z".len(), "{now}"); assert!(now.ends_with('Z') && now.get(10..11) == Some("T"), "{now}"); From 2b2a2b4d864159c9351b82978227d4882925c9a8 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:06:47 +1100 Subject: [PATCH 11/39] Name the leap-year cycle constants in civil() --- crates/lsp-profiler/src/clock.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs index 3721c72..81846c8 100644 --- a/crates/lsp-profiler/src/clock.rs +++ b/crates/lsp-profiler/src/clock.rs @@ -26,6 +26,10 @@ const YEAR_DAYS: i128 = 365; const LEAP_CYCLE_DAYS: i128 = 1_460; /// Days in a century that skips its leap day. const CENTURY_DAYS: i128 = 36_524; +/// Years between Julian leap days. +const LEAP_YEAR_EVERY: i128 = 4; +/// Years in a century, whose leap day is skipped. +const CENTURY_YEARS: i128 = 100; /// Years in a Gregorian era. const ERA_YEARS: i128 = 400; /// Hinnant's month-from-day-of-year line: month = (5·doy + 2) / 153. @@ -72,7 +76,8 @@ fn civil(days: i128) -> (i128, i128, i128) { - day_of_era.div_euclid(ERA_DAYS - 1)) .div_euclid(YEAR_DAYS); let day_of_year = day_of_era - - (YEAR_DAYS * year_of_era + year_of_era.div_euclid(4) - year_of_era.div_euclid(100)); + - (YEAR_DAYS * year_of_era + year_of_era.div_euclid(LEAP_YEAR_EVERY) + - year_of_era.div_euclid(CENTURY_YEARS)); let (slope, offset, span) = MONTH_SLOPE; let march_month = (slope * day_of_year + offset).div_euclid(span); let day = day_of_year - (span * march_month + offset).div_euclid(slope) + 1; From 53436f425393790fff32152c531e0f2078d747ea Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:11:21 +1100 Subject: [PATCH 12/39] Review v0.5.0..2b2a2b4: URI separator and host-decoding findings, unwrap_or sites, breaking changes --- docs/plans/review-v0.5.0-to-v0.6.0.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 docs/plans/review-v0.5.0-to-v0.6.0.md diff --git a/docs/plans/review-v0.5.0-to-v0.6.0.md b/docs/plans/review-v0.5.0-to-v0.6.0.md new file mode 100644 index 0000000..eec04bc --- /dev/null +++ b/docs/plans/review-v0.5.0-to-v0.6.0.md @@ -0,0 +1,20 @@ +# Review: v0.5.0 → fix/issues-21-26-48-49 (2b2a2b4) + +Scope: `git diff v0.5.0..2b2a2b4`, 31 files, +1335/−75. The production code under review is `uri.rs` (#49, PR #50), `outbound.rs` and `jsonrpc.rs` (#48), `correlator.rs`, and `clock.rs` (which replaces humantime). The rmcp and humantime removals, the `mcp` feature removal and the toolchain pin are also covered. + +## Findings, most severe first + +- [ ] **URI-DECODE-SEPARATOR** `crates/lspkit-server/src/uri.rs:70-81`: the URI is percent-decoded before it is split into segments. `%2F` and `%5C` therefore become real separators: `file:///C:/a%5Cb.rs` decodes to `C:\a\b.rs`, and on Unix `file:///tmp/a%2Fb` decodes to `/tmp/a/b`. The existing tests `lowercase_hex_percent_decodes` and `uppercase_hex_percent_decodes` (`tests/uri.rs:91-102`) assert this behaviour, but the #49 Windows plan requires the opposite: an encoded separator never becomes one. Fix: reject a decoded `/` or `\` inside a segment with `UriError::NoLocalPath`, and replace those two tests with rejection tests (a deliberate behaviour change, recorded in the spec). +- [ ] **URI-HOST-INJECTION** `uri.rs:71,79`: the authority is percent-decoded and then pasted into a UNC prefix, so `file://host%5Cshare%5Cx/a.rs` becomes `\\host\share\x\a.rs`. A host containing `/`, `\`, `?` or `:` after decoding must be rejected. +- [ ] **UNWRAP-OR** `uri.rs:70,88,124,140`: four `unwrap_or`/`unwrap_or_else` calls in new production code, which the user has banned. Replace them with `split_once`/`match`. +- [ ] **URI-NON-ROUNDTRIP** `uri.rs:117-140`: `path_to_uri` returns `Ok` for Windows paths that `uri_to_path` then rejects: `\\server` (no share) gives `file://server`, and `\\?\Volume{GUID}\x` gives `file:///Volume%7B…`. `path_to_uri` should return `InvalidPath` for both rather than emit a URI that never decodes. +- [ ] **BREAKING-MCP-FEATURE** `crates/lspkit-server/Cargo.toml`: removing the `mcp` feature breaks `cargo add lspkit-server --features mcp` for existing consumers with "unknown feature". This was intentional (rmcp was unused and pulled the unmaintained chrono), but the v0.6.0 release notes must say so. +- [ ] **BREAKING-PROFILER-PATH** `crates/lsp-profiler`: `lsp_profiler::session::rfc3339_now` moved to `lsp_profiler::clock::rfc3339_now`. No in-repo consumer uses it; release notes. +- [ ] **TIMING-TESTS** `crates/lsp-profiler-dotnet/tests/dotnet_e2e.rs:270,296`: both tests assert `elapsed < 5s` and fail under load (5.5 s seen at load average 10), which breaks the repo's "Deterministic, no timing" rule. This predates the diff but blocks local `make ci` on a busy machine. + +## Verified sound + +- `Outbound`: a registration released on `IdsExhausted` (`PendingResponse` drop), unknown/duplicate/foreign ids rejected visibly, heap proven by `outbound_heap_leak.rs`, routing proven by the 1↔2 swap mutant. +- `wire_params`: null `params` omitted per JSON-RPC 2.0; `"result": null` is still emitted for responses. +- `clock.rs`: Hinnant civil-from-days, floor before the epoch, century leap rows (1600/1900/2000/2100/2400), mutants killed (DeslopClaude1, SharpLsp1). +- Dependency removals: `cargo deny` and `osv-scanner` clean; rmcp was never called. From eb556d067935e146fda35c1f6a3cbe4ee181cef3 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:13:41 +1100 Subject: [PATCH 13/39] Gate uri_authority.rs at file level so the Windows target compiles without unused imports --- crates/lspkit-server/tests/uri_authority.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/lspkit-server/tests/uri_authority.rs b/crates/lspkit-server/tests/uri_authority.rs index ce97332..216a514 100644 --- a/crates/lspkit-server/tests/uri_authority.rs +++ b/crates/lspkit-server/tests/uri_authority.rs @@ -1,12 +1,13 @@ //! [URI-AUTHORITY] Issue #49 through the public API only, so this file also //! compiles against the pre-fix crate and fails there on the exact symptom. +//! Unix-only: the Windows rows live in the Windows-hosted suite. +#![cfg(not(windows))] use std::path::PathBuf; use lspkit_server::{path_to_uri, uri_to_path}; /// A `localhost` or empty authority is the host, never the first path folder. -#[cfg(not(windows))] #[test] fn localhost_authority_is_the_host_not_a_folder() { for uri in [ From 4d6dbde551aca829d20d869f5af8368b1d074d1d Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:14:52 +1100 Subject: [PATCH 14/39] Review: record the reproduced uri.rs findings; take the Windows rewrite and keep the cross-check tests --- .../tests/common/held_source/windows.rs | 10 +++++--- docs/plans/review-v0.5.0-to-v0.6.0.md | 23 +++++++++++++++---- test-support/windows-oplock/owner.rs | 10 ++++---- 3 files changed, 32 insertions(+), 11 deletions(-) diff --git a/crates/lspkit-server/tests/common/held_source/windows.rs b/crates/lspkit-server/tests/common/held_source/windows.rs index 38f9de9..ebbdc99 100644 --- a/crates/lspkit-server/tests/common/held_source/windows.rs +++ b/crates/lspkit-server/tests/common/held_source/windows.rs @@ -23,8 +23,12 @@ impl NativeSource { /// Write the real held source and start the owner holding it. pub fn new(source: &Path) -> StepResult { std::fs::write(source, b"{\"unfinished\":")?; - let mut child = spawn_owner(source); - let stdout = child.stdout.take().ok_or("oplock stdout")?; + let mut child = spawn_owner(source)?; + let Some(stdout) = child.stdout.take() else { + child.kill()?; + child.wait()?; + return Err("oplock stdout".into()); + }; let mut held = HeldRead { child, output: BufReader::new(stdout), @@ -42,7 +46,7 @@ impl NativeSource { } /// Run the owned native fixture invisibly, with no persistent policy changes. -fn spawn_owner(source: &Path) -> Child { +fn spawn_owner(source: &Path) -> std::io::Result { let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test-support/windows-oplock/hold.ps1"); owner::spawn(&script, source) diff --git a/docs/plans/review-v0.5.0-to-v0.6.0.md b/docs/plans/review-v0.5.0-to-v0.6.0.md index eec04bc..30501b0 100644 --- a/docs/plans/review-v0.5.0-to-v0.6.0.md +++ b/docs/plans/review-v0.5.0-to-v0.6.0.md @@ -4,14 +4,29 @@ Scope: `git diff v0.5.0..2b2a2b4`, 31 files, +1335/−75. The production code un ## Findings, most severe first -- [ ] **URI-DECODE-SEPARATOR** `crates/lspkit-server/src/uri.rs:70-81`: the URI is percent-decoded before it is split into segments. `%2F` and `%5C` therefore become real separators: `file:///C:/a%5Cb.rs` decodes to `C:\a\b.rs`, and on Unix `file:///tmp/a%2Fb` decodes to `/tmp/a/b`. The existing tests `lowercase_hex_percent_decodes` and `uppercase_hex_percent_decodes` (`tests/uri.rs:91-102`) assert this behaviour, but the #49 Windows plan requires the opposite: an encoded separator never becomes one. Fix: reject a decoded `/` or `\` inside a segment with `UriError::NoLocalPath`, and replace those two tests with rejection tests (a deliberate behaviour change, recorded in the spec). -- [ ] **URI-HOST-INJECTION** `uri.rs:71,79`: the authority is percent-decoded and then pasted into a UNC prefix, so `file://host%5Cshare%5Cx/a.rs` becomes `\\host\share\x\a.rs`. A host containing `/`, `\`, `?` or `:` after decoding must be rejected. -- [ ] **UNWRAP-OR** `uri.rs:70,88,124,140`: four `unwrap_or`/`unwrap_or_else` calls in new production code, which the user has banned. Replace them with `split_once`/`match`. -- [ ] **URI-NON-ROUNDTRIP** `uri.rs:117-140`: `path_to_uri` returns `Ok` for Windows paths that `uri_to_path` then rejects: `\\server` (no share) gives `file://server`, and `\\?\Volume{GUID}\x` gives `file:///Volume%7B…`. `path_to_uri` should return `InvalidPath` for both rather than emit a URI that never decodes. +- [x] **URI-DECODE-SEPARATOR** `crates/lspkit-server/src/uri.rs:70-81`: the URI is percent-decoded before it is split into segments. `%2F` and `%5C` therefore become real separators: `file:///C:/a%5Cb.rs` decodes to `C:\a\b.rs`, and on Unix `file:///tmp/a%2Fb` decodes to `/tmp/a/b`. The existing tests `lowercase_hex_percent_decodes` and `uppercase_hex_percent_decodes` (`tests/uri.rs:91-102`) assert this behaviour, but the #49 Windows plan requires the opposite: an encoded separator never becomes one. Fix: reject a decoded `/` or `\` inside a segment with `UriError::NoLocalPath`, and replace those two tests with rejection tests (a deliberate behaviour change, recorded in the spec). +- [x] **URI-HOST-INJECTION** `uri.rs:71,79`: the authority is percent-decoded and then pasted into a UNC prefix, so `file://host%5Cshare%5Cx/a.rs` becomes `\\host\share\x\a.rs`. Fixed: an encoded `/` or `\` in the host is `NoLocalPath`. +- [x] **UNWRAP-OR** `uri.rs:70,88,124,140`: four `unwrap_or`/`unwrap_or_else` calls in new production code, which the user has banned. Replace them with `split_once`/`match`. +- [x] **URI-NON-ROUNDTRIP** `uri.rs:117-140`: `path_to_uri` returns `Ok` for Windows paths that `uri_to_path` then rejects: `\\server` (no share) gives `file://server`, and `\\?\Volume{GUID}\x` gives `file:///Volume%7B…`. `path_to_uri` should return `InvalidPath` for both rather than emit a URI that never decodes. - [ ] **BREAKING-MCP-FEATURE** `crates/lspkit-server/Cargo.toml`: removing the `mcp` feature breaks `cargo add lspkit-server --features mcp` for existing consumers with "unknown feature". This was intentional (rmcp was unused and pulled the unmaintained chrono), but the v0.6.0 release notes must say so. - [ ] **BREAKING-PROFILER-PATH** `crates/lsp-profiler`: `lsp_profiler::session::rfc3339_now` moved to `lsp_profiler::clock::rfc3339_now`. No in-repo consumer uses it; release notes. - [ ] **TIMING-TESTS** `crates/lsp-profiler-dotnet/tests/dotnet_e2e.rs:270,296`: both tests assert `elapsed < 5s` and fail under load (5.5 s seen at load average 10), which breaks the repo's "Deterministic, no timing" rule. This predates the diff but blocks local `make ci` on a busy machine. +## URI fixes: red → green + +The four `uri.rs` findings were reproduced red and fixed locally. The Windows agent's rewrite of `uri.rs` (see the #49 "Windows results" comment) fixes all four and more, so this branch takes that rewrite instead of a second, conflicting change. These red results stand as cross-check tests to apply on top of it: + +```text +uri::style_tests::encoded_separators_never_become_path_boundaries ... FAILED + forged separator: "C:\\a\\b.rs" +uri::style_tests::windows_paths_no_uri_decodes_back_to_are_rejected ... FAILED + left: Some("file://server") right: None +tests/uri.rs encoded_slash_is_rejected_not_split_into_folders ... FAILED + an encoded slash: "/tmp/a/b" +``` + +- [ ] Once the Windows rewrite lands, apply the cross-check tests (Unix `%2F` rejection, `%252F` stays literal, Unix `%5C` is a name byte, encoded separators in the host) and confirm they pass. + ## Verified sound - `Outbound`: a registration released on `IdsExhausted` (`PendingResponse` drop), unknown/duplicate/foreign ids rejected visibly, heap proven by `outbound_heap_leak.rs`, routing proven by the 1↔2 swap mutant. diff --git a/test-support/windows-oplock/owner.rs b/test-support/windows-oplock/owner.rs index 992bbf7..5a0113a 100644 --- a/test-support/windows-oplock/owner.rs +++ b/test-support/windows-oplock/owner.rs @@ -4,8 +4,11 @@ use std::os::windows::process::CommandExt; use std::path::Path; use std::process::{Child, ChildStdout, Command, Stdio}; +/// `CREATE_NO_WINDOW`: the owner never opens a console window. +const CREATE_NO_WINDOW: u32 = 0x0800_0000; + /// Run only the owned oplock fixture, invisibly and without persistent policy changes. -pub fn spawn(script: &Path, source: &Path) -> Child { +pub fn spawn(script: &Path, source: &Path) -> io::Result { Command::new("powershell.exe") .args([ "-NoProfile", @@ -14,7 +17,7 @@ pub fn spawn(script: &Path, source: &Path) -> Child { "Bypass", "-File", ]) - .creation_flags(0x0800_0000) + .creation_flags(CREATE_NO_WINDOW) .arg(script) .arg("-Source") .arg(source) @@ -22,7 +25,6 @@ pub fn spawn(script: &Path, source: &Path) -> Child { .stdout(Stdio::piped()) .stderr(Stdio::piped()) .spawn() - .expect("start owned native source owner") } /// Parse fixture state, never infer readiness from elapsed time. @@ -30,7 +32,7 @@ pub fn state(output: &mut BufReader, expected: &str) -> io::Result< let mut line = String::new(); let _length = output.read_line(&mut line)?; let value: serde_json::Value = serde_json::from_str(&line).map_err(io::Error::other)?; - if value["state"] != expected { + if value.get("state").and_then(serde_json::Value::as_str) != Some(expected) { return Err(io::Error::other("unexpected native source state")); } Ok(()) From 0c42960d310cd60d87db878bd728e54e8e28807e Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:15:03 +1100 Subject: [PATCH 15/39] Review: URI findings stay open until the Windows rewrite lands --- docs/plans/review-v0.5.0-to-v0.6.0.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/plans/review-v0.5.0-to-v0.6.0.md b/docs/plans/review-v0.5.0-to-v0.6.0.md index 30501b0..6a5a38a 100644 --- a/docs/plans/review-v0.5.0-to-v0.6.0.md +++ b/docs/plans/review-v0.5.0-to-v0.6.0.md @@ -4,10 +4,10 @@ Scope: `git diff v0.5.0..2b2a2b4`, 31 files, +1335/−75. The production code un ## Findings, most severe first -- [x] **URI-DECODE-SEPARATOR** `crates/lspkit-server/src/uri.rs:70-81`: the URI is percent-decoded before it is split into segments. `%2F` and `%5C` therefore become real separators: `file:///C:/a%5Cb.rs` decodes to `C:\a\b.rs`, and on Unix `file:///tmp/a%2Fb` decodes to `/tmp/a/b`. The existing tests `lowercase_hex_percent_decodes` and `uppercase_hex_percent_decodes` (`tests/uri.rs:91-102`) assert this behaviour, but the #49 Windows plan requires the opposite: an encoded separator never becomes one. Fix: reject a decoded `/` or `\` inside a segment with `UriError::NoLocalPath`, and replace those two tests with rejection tests (a deliberate behaviour change, recorded in the spec). -- [x] **URI-HOST-INJECTION** `uri.rs:71,79`: the authority is percent-decoded and then pasted into a UNC prefix, so `file://host%5Cshare%5Cx/a.rs` becomes `\\host\share\x\a.rs`. Fixed: an encoded `/` or `\` in the host is `NoLocalPath`. -- [x] **UNWRAP-OR** `uri.rs:70,88,124,140`: four `unwrap_or`/`unwrap_or_else` calls in new production code, which the user has banned. Replace them with `split_once`/`match`. -- [x] **URI-NON-ROUNDTRIP** `uri.rs:117-140`: `path_to_uri` returns `Ok` for Windows paths that `uri_to_path` then rejects: `\\server` (no share) gives `file://server`, and `\\?\Volume{GUID}\x` gives `file:///Volume%7B…`. `path_to_uri` should return `InvalidPath` for both rather than emit a URI that never decodes. +- [ ] **URI-DECODE-SEPARATOR** `crates/lspkit-server/src/uri.rs:70-81`: the URI is percent-decoded before it is split into segments. `%2F` and `%5C` therefore become real separators: `file:///C:/a%5Cb.rs` decodes to `C:\a\b.rs`, and on Unix `file:///tmp/a%2Fb` decodes to `/tmp/a/b`. The existing tests `lowercase_hex_percent_decodes` and `uppercase_hex_percent_decodes` (`tests/uri.rs:91-102`) assert this behaviour, but the #49 Windows plan requires the opposite: an encoded separator never becomes one. Fix: reject a decoded `/` or `\` inside a segment with `UriError::NoLocalPath`, and replace those two tests with rejection tests (a deliberate behaviour change, recorded in the spec). +- [ ] **URI-HOST-INJECTION** `uri.rs:71,79`: the authority is percent-decoded and then pasted into a UNC prefix, so `file://host%5Cshare%5Cx/a.rs` becomes `\\host\share\x\a.rs`. Fixed: an encoded `/` or `\` in the host is `NoLocalPath`. +- [ ] **UNWRAP-OR** `uri.rs:70,88,124,140`: four `unwrap_or`/`unwrap_or_else` calls in new production code, which the user has banned. Replace them with `split_once`/`match`. +- [ ] **URI-NON-ROUNDTRIP** `uri.rs:117-140`: `path_to_uri` returns `Ok` for Windows paths that `uri_to_path` then rejects: `\\server` (no share) gives `file://server`, and `\\?\Volume{GUID}\x` gives `file:///Volume%7B…`. `path_to_uri` should return `InvalidPath` for both rather than emit a URI that never decodes. - [ ] **BREAKING-MCP-FEATURE** `crates/lspkit-server/Cargo.toml`: removing the `mcp` feature breaks `cargo add lspkit-server --features mcp` for existing consumers with "unknown feature". This was intentional (rmcp was unused and pulled the unmaintained chrono), but the v0.6.0 release notes must say so. - [ ] **BREAKING-PROFILER-PATH** `crates/lsp-profiler`: `lsp_profiler::session::rfc3339_now` moved to `lsp_profiler::clock::rfc3339_now`. No in-repo consumer uses it; release notes. - [ ] **TIMING-TESTS** `crates/lsp-profiler-dotnet/tests/dotnet_e2e.rs:270,296`: both tests assert `elapsed < 5s` and fail under load (5.5 s seen at load average 10), which breaks the repo's "Deterministic, no timing" rule. This predates the diff but blocks local `make ci` on a busy machine. From f8460c4366c31373861c5384e30e7782778849af Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:15:15 +1100 Subject: [PATCH 16/39] Make the Windows-only oplock test helpers pass clippy: no expect, no indexing, reap the owner on early exit --- crates/lspkit-server/tests/common/held_source/windows.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/lspkit-server/tests/common/held_source/windows.rs b/crates/lspkit-server/tests/common/held_source/windows.rs index ebbdc99..585a570 100644 --- a/crates/lspkit-server/tests/common/held_source/windows.rs +++ b/crates/lspkit-server/tests/common/held_source/windows.rs @@ -26,7 +26,7 @@ impl NativeSource { let mut child = spawn_owner(source)?; let Some(stdout) = child.stdout.take() else { child.kill()?; - child.wait()?; + let _killed = child.wait()?; return Err("oplock stdout".into()); }; let mut held = HeldRead { From 51185c77fec33bcd7941f0974c1dc40e77d52f6e Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:16:24 +1100 Subject: [PATCH 17/39] lspkit-server: drop the unused futures-util runtime dependency (tests keep it as a dev-dependency) --- crates/lspkit-server/Cargo.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/lspkit-server/Cargo.toml b/crates/lspkit-server/Cargo.toml index 0c5f459..3caac57 100644 --- a/crates/lspkit-server/Cargo.toml +++ b/crates/lspkit-server/Cargo.toml @@ -22,7 +22,6 @@ workspace = true lspkit.workspace = true async-trait.workspace = true -futures-util.workspace = true lsp-types.workspace = true notify.workspace = true serde.workspace = true From 7f37353b56780675c7ac3e9f439c337e394e8653 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:21:00 +1100 Subject: [PATCH 18/39] Windows URI rewrite for #49: one parsed path for both directions, the plan's table run on Windows uri.rs parses every Windows path, from a URI or from a native path, into one normalised WindowsPath (drive or UNC root, segments, trailing separator) and renders both forms from it. All path handling stays in this one module, and both styles share one percent decoder and one encoder. Fixed on Windows (each was red on PR #50's uri.rs): - A URI host can no longer reach a device path: file://%3F/C:/a.rs and file://./C:/a.rs are NoLocalPath, and \.\, \?\Volume{..} and \?\GLOBALROOT paths are InvalidPath. - Hosts with a port, userinfo or an encoded separator are rejected. - %2F (and %5C on Windows) inside a name is rejected on every platform, never split on. - One file, one URI: the drive letter is upper case and the server name lower case, repeated separators collapse, and . and .. resolve. - Names Win32 would rewrite (a trailing dot or space, NUL, CON, aux.rs) decode to the \?\ form, so they open the file they name. - file:////server/share and [ipv6] hosts decode to UNC paths. - A % not followed by two hex digits is InvalidUtf8 on every platform. src/uri_cases.rs holds the #49 Windows plan's table once. uri_style_tests.rs runs it through Style::Windows on every OS, and tests/uri_windows.rs runs it through the public API on a Windows build, together with real-filesystem rows: canonicalize output, a path over 260 characters, a junction, 8.3 names, reserved names and drive-letter case. On Windows 11, uri_windows passes 0/10 on 384b341~1, 4/10 on PR #50 and 10/10 now. Co-Authored-By: Claude Opus 5.5 --- crates/lspkit-server/src/uri.rs | 304 ++++++++++++++++---- crates/lspkit-server/src/uri_cases.rs | 244 ++++++++++++++++ crates/lspkit-server/src/uri_style_tests.rs | 107 +++---- crates/lspkit-server/tests/uri.rs | 43 ++- crates/lspkit-server/tests/uri_authority.rs | 2 +- crates/lspkit-server/tests/uri_windows.rs | 265 +++++++++++++++++ docs/specs/lspkit-spec.md | 5 + 7 files changed, 845 insertions(+), 125 deletions(-) create mode 100644 crates/lspkit-server/src/uri_cases.rs create mode 100644 crates/lspkit-server/tests/uri_windows.rs diff --git a/crates/lspkit-server/src/uri.rs b/crates/lspkit-server/src/uri.rs index f2d50ad..92015f4 100644 --- a/crates/lspkit-server/src/uri.rs +++ b/crates/lspkit-server/src/uri.rs @@ -1,7 +1,8 @@ -//! URI ↔ `PathBuf` conversion. +//! URI ↔ `PathBuf` conversion: the one place lspkit turns file paths into URIs +//! and back. //! //! Handles `file://`, URI authorities, percent-decoding, Windows drive letters, -//! UNC paths and extended-length prefixes ([URI-AUTHORITY]). +//! UNC paths and extended-length prefixes ([URI-AUTHORITY], [URI-WINDOWS]). use std::path::{Path, PathBuf}; @@ -12,7 +13,7 @@ pub enum UriError { /// URI scheme is not `file://`. #[error("unsupported URI scheme: {0}")] UnsupportedScheme(String), - /// Percent-decoded URI is not valid UTF-8, retaining conversion failures. + /// Percent-decoded URI is not valid UTF-8, or holds a malformed `%` escape. #[error("URI is not valid UTF-8 after percent decoding")] InvalidUtf8(#[source] Option), /// Path could not be converted to a URI. @@ -33,6 +34,15 @@ const UNC_PREFIX: &str = r"\\"; const VERBATIM_UNC_PREFIX: &str = r"\\?\UNC\"; /// Windows extended-length prefix of a drive path. const VERBATIM_PREFIX: &str = r"\\?\"; +/// Domain Windows uses to spell an IPv6 literal as a UNC server name. +const IPV6_LITERAL_SUFFIX: &str = ".ipv6-literal.net"; +/// Characters a UNC server name cannot hold, including a URI's userinfo and port. +const HOST_FORBIDDEN: [char; 12] = ['\\', '/', ':', '*', '?', '"', '<', '>', '|', '@', '[', ']']; +/// Device names Win32 resolves in place of a file whose name starts with one. +const DOS_DEVICES: [&str; 22] = [ + "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", + "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", +]; /// Path syntax of the platform a conversion targets. #[derive(Clone, Copy, Debug)] @@ -53,7 +63,9 @@ const NATIVE: Style = if cfg!(windows) { /// Convert a `file://` URI to an absolute `PathBuf` ([URI-AUTHORITY]). /// /// An empty or `localhost` authority names a local path; any other host -/// names a UNC path on Windows. +/// names a UNC path on Windows. On Windows the drive letter is upper case, +/// the server name lower case, and the `\\?\` form is returned only when +/// Win32 would otherwise open a different file ([URI-WINDOWS]). /// /// # Errors /// Returns [`UriError`] for non-`file` schemes, invalid percent encoding, or @@ -67,90 +79,272 @@ fn uri_to_native(uri: &str, style: Style) -> Result { let rest = uri .strip_prefix(FILE_SCHEME) .ok_or_else(|| UriError::UnsupportedScheme(uri.to_owned()))?; - let (authority, path) = rest.split_at(rest.find('/').unwrap_or(rest.len())); + let (authority, path) = match rest.find('/') { + Some(at) => rest.split_at(at), + None => (rest, ""), + }; let host = percent_decode(authority)?; - let path = percent_decode(path)?; let local = host.is_empty() || host.eq_ignore_ascii_case(LOCAL_HOST); + let no_path = || UriError::NoLocalPath(uri.to_owned()); + // Each segment is decoded on its own, so an encoded `%2F` (or `%5C` on + // Windows) stays inside its name and is rejected, never split on. + let segments = path + .split('/') + .skip(1) + .map(percent_decode) + .collect::, _>>()?; + if segments + .iter() + .any(|segment| segment.contains(style.separators())) + { + return Err(no_path()); + } match (style, local) { - (Style::Unix, true) if path.is_empty() => Ok("/".to_owned()), - (Style::Unix, true) => Ok(path), - (Style::Windows, true) => windows_drive_path(uri, &path), - (Style::Windows, false) if path.trim_matches('/').is_empty() => { - Err(UriError::NoLocalPath(uri.to_owned())) - } - (Style::Windows, false) => Ok(format!("{UNC_PREFIX}{host}{}", path.replace('/', "\\"))), - (Style::Unix, false) => Err(UriError::NoLocalPath(uri.to_owned())), + (Style::Unix, true) => Ok(format!("/{}", segments.join("/"))), + (Style::Unix, false) => Err(no_path()), + (Style::Windows, _) => WindowsPath::from_uri((!local).then_some(host.as_str()), segments) + .map(|parsed| parsed.native()) + .ok_or_else(no_path), } } -/// `/C:/repo/a.rs` → `C:\repo\a.rs`; anything without a drive root is rejected. -fn windows_drive_path(uri: &str, path: &str) -> Result { - let native = path.strip_prefix('/').unwrap_or(path).replace('/', "\\"); - match native.as_bytes() { - [letter, b':', b'\\', ..] if letter.is_ascii_alphabetic() => Ok(native), - _ => Err(UriError::NoLocalPath(uri.to_owned())), +impl Style { + /// Characters that separate path segments, so never appear inside one. + const fn separators(self) -> &'static [char] { + match self { + Self::Unix => &['/'], + Self::Windows => &['/', '\\'], + } } } /// Convert an absolute filesystem path to a `file://` URI ([URI-AUTHORITY]). /// /// A Windows UNC path keeps its server as the URI authority, and the -/// extended-length prefixes `\\?\` and `\\?\UNC\` are removed. +/// extended-length prefixes `\\?\` and `\\?\UNC\` are removed. One file has +/// one URI: drive letters are upper case, server names lower case, and +/// repeated separators collapse ([URI-WINDOWS]). /// /// # Errors -/// Returns [`UriError::InvalidPath`] if the path is not absolute or contains -/// components that cannot be expressed in a URI. +/// Returns [`UriError::InvalidPath`] if the path is not absolute, is a +/// Windows device path (`\\.\`, `\\?\Volume{…}`), or contains components +/// that cannot be expressed in a URI. pub fn path_to_uri(path: &Path) -> Result { - if !path.is_absolute() { - return Err(UriError::InvalidPath(path.to_path_buf())); - } - path.to_str() - .map(|text| native_to_uri(text, NATIVE)) + Some(path) + .filter(|path| path.is_absolute()) + .and_then(Path::to_str) + .and_then(|text| native_to_uri(text, NATIVE)) .ok_or_else(|| UriError::InvalidPath(path.to_path_buf())) } -/// Renders an absolute path written in `style` as a `file://` URI. -fn native_to_uri(path: &str, style: Style) -> String { +/// Renders an absolute path written in `style` as a `file://` URI, or `None` +/// when it names no file a URI can reach. +fn native_to_uri(path: &str, style: Style) -> Option { match style { - Style::Unix => format!("{FILE_SCHEME}{}", percent_encode(path)), - Style::Windows => windows_to_uri(&without_verbatim(path).replace('\\', "/")), + Style::Unix => Some(format!("{FILE_SCHEME}{}", percent_encode(path))), + Style::Windows => WindowsPath::from_native(path).map(|parsed| parsed.uri()), } } -/// `//server/share/a.rs` → `file://server/share/a.rs`; `C:/a.rs` → `file:///C:/a.rs`. -fn windows_to_uri(forward: &str) -> String { - match forward.strip_prefix("//") { - Some(unc) => { - let (host, path) = unc.split_at(unc.find('/').unwrap_or(unc.len())); - format!( - "{FILE_SCHEME}{}{}", +/// Where an absolute Windows path is rooted. +enum Root { + /// `C:\`; the letter is upper case. + Drive(char), + /// `\\server\share`; the server name is lower case. + Unc { + /// Server name. + host: String, + /// Share name. + share: String, + }, +} + +/// An absolute Windows path with no empty, `.` or `..` segments: the single +/// form both conversion directions parse into and render from. +struct WindowsPath { + /// Drive or network root. + root: Root, + /// Folder and file names below the root. + segments: Vec, + /// Whether the path ends in a separator (`C:\repo\`). + trailing: bool, +} + +impl WindowsPath { + /// Parses a URI's decoded path segments; `host` is `None` for the local machine. + /// `file:////server/share` (an empty authority before a UNC path) is accepted. + fn from_uri(host: Option<&str>, segments: Vec) -> Option { + let mut parts = segments.into_iter(); + match host { + Some(host) => Self::unc(host, parts), + None => match parts.next()? { + first if first.is_empty() => { + let host = parts.next()?; + Self::unc(&host, parts) + } + first => Self::drive(&first, parts), + }, + } + } + + /// Parses an absolute Windows path, removing an extended-length prefix. + /// Device paths (`\\.\`, `\\?\Volume{…}`) name no file and give `None`. + fn from_native(path: &str) -> Option { + let is_separator = |c: char| c == '\\' || c == '/'; + if let Some(unc) = path.strip_prefix(VERBATIM_UNC_PREFIX) { + let mut parts = unc.split(is_separator).map(str::to_owned); + let host = parts.next()?; + return Self::unc(&host, parts); + } + if let Some(drive) = path.strip_prefix(VERBATIM_PREFIX) { + let mut parts = drive.split(is_separator).map(str::to_owned); + let first = parts.next()?; + return Self::drive(&first, parts); + } + let mut parts = path.split(is_separator).map(str::to_owned); + let first = parts.next()?; + if !first.is_empty() { + return Self::drive(&first, parts); + } + // A leading separator must be the pair that opens `\\server\share`. + let host = parts + .next() + .filter(String::is_empty) + .and_then(|_| parts.next())?; + Self::unc(&host, parts) + } + + /// `C:` followed by at least one separator. + fn drive(first: &str, rest: impl Iterator) -> Option { + let letter = match first.as_bytes() { + [letter, b':'] if letter.is_ascii_alphabetic() => { + char::from(letter.to_ascii_uppercase()) + } + _ => return None, + }; + let mut rest = rest.peekable(); + rest.peek() + .is_some() + .then(|| Self::below(Root::Drive(letter), rest)) + } + + /// `\\server\share`, with a reachable server name and a non-empty share. + fn unc(host: &str, mut rest: impl Iterator) -> Option { + let host = unc_host(host)?; + let share = rest.next().filter(|share| !share.is_empty())?; + Some(Self::below(Root::Unc { host, share }, rest)) + } + + /// Resolves `.`, `..` and empty segments lexically, as Win32 does; `..` + /// never climbs above the root. + fn below(root: Root, raw: impl Iterator) -> Self { + let mut segments = Vec::new(); + let mut trailing = false; + for segment in raw { + trailing = segment.is_empty(); + match segment.as_str() { + "" | "." => {} + ".." => segments.truncate(segments.len().saturating_sub(1)), + _ => segments.push(segment), + } + } + Self { + root, + segments, + trailing, + } + } + + /// The native path, extended-length only when Win32 would otherwise + /// rewrite a segment into a different file. + fn native(&self) -> String { + let verbatim = self.segments.iter().any(|segment| win32_rewrites(segment)); + let head = match (&self.root, verbatim) { + (Root::Drive(letter), false) => format!(r"{letter}:\"), + (Root::Drive(letter), true) => format!(r"{VERBATIM_PREFIX}{letter}:\"), + (Root::Unc { host, share }, false) => format!(r"{UNC_PREFIX}{host}\{share}"), + (Root::Unc { host, share }, true) => format!(r"{VERBATIM_UNC_PREFIX}{host}\{share}"), + }; + self.render(head, '\\', str::to_owned) + } + + /// The canonical `file://` URI. + fn uri(&self) -> String { + let head = match &self.root { + Root::Drive(letter) => format!("{FILE_SCHEME}/{letter}:/"), + Root::Unc { host, share } => format!( + "{FILE_SCHEME}{}/{}", percent_encode(host), - percent_encode(path) - ) + percent_encode(share) + ), + }; + self.render(head, '/', percent_encode) + } + + /// Writes `head`, then each segment through `spell`, separated by `separator`. + fn render(&self, head: String, separator: char, spell: impl Fn(&str) -> String) -> String { + let mut out = head; + for segment in &self.segments { + if !out.ends_with(separator) { + out.push(separator); + } + out.push_str(&spell(segment)); } - None => format!("{FILE_SCHEME}/{}", percent_encode(forward)), + if self.trailing && !out.ends_with(separator) { + out.push(separator); + } + out } } -/// Removes the extended-length prefix `std::fs::canonicalize` adds on Windows. -fn without_verbatim(path: &str) -> String { - path.strip_prefix(VERBATIM_UNC_PREFIX) - .map(|unc| format!("{UNC_PREFIX}{unc}")) - .or_else(|| path.strip_prefix(VERBATIM_PREFIX).map(str::to_owned)) - .unwrap_or_else(|| path.to_owned()) +/// The lower-case UNC server name for a URI host or path server, with an +/// IPv6 literal `[fe80::1]` spelled `fe80--1.ipv6-literal.net`. Device +/// namespaces (`.`, `?`), ports and userinfo name no server. +fn unc_host(raw: &str) -> Option { + let host = match raw + .strip_prefix('[') + .and_then(|inner| inner.strip_suffix(']')) + { + Some(ipv6) => format!( + "{}{IPV6_LITERAL_SUFFIX}", + ipv6.replace(':', "-").replace('%', "s") + ), + None => raw.to_owned(), + }; + let reachable = !matches!(host.as_str(), "" | "." | "?") && !host.contains(HOST_FORBIDDEN); + reachable.then(|| host.to_ascii_lowercase()) +} + +/// Whether Win32 opens something other than `segment` when it is written +/// without `\\?\`: a trailing dot or space is dropped, and a DOS device name +/// opens the device. +fn win32_rewrites(segment: &str) -> bool { + let stem = match segment.split_once('.') { + Some((stem, _extension)) => stem, + None => segment, + } + .trim_end_matches(' '); + segment.ends_with(['.', ' ']) + || DOS_DEVICES + .iter() + .any(|device| device.eq_ignore_ascii_case(stem)) } -/// Decodes complete percent triplets and preserves incomplete trailing input. +/// Decodes `%XX` escapes; a `%` not followed by two hex digits is an error. fn percent_decode(input: &str) -> Result { let mut out = Vec::with_capacity(input.len()); let mut rest = input.as_bytes(); while let Some((&byte, tail)) = rest.split_first() { - rest = if let (b'%', [hi, lo, after @ ..]) = (byte, tail) { - out.push((hex_digit(*hi)? << 4) | hex_digit(*lo)?); - after - } else { - out.push(byte); - tail + rest = match (byte, tail) { + (b'%', [hi, lo, after @ ..]) => { + out.push((hex_digit(*hi)? << 4) | hex_digit(*lo)?); + after + } + (b'%', _) => return Err(UriError::InvalidUtf8(None)), + _ => { + out.push(byte); + tail + } }; } String::from_utf8(out).map_err(|source| UriError::InvalidUtf8(Some(source))) diff --git a/crates/lspkit-server/src/uri_cases.rs b/crates/lspkit-server/src/uri_cases.rs new file mode 100644 index 0000000..cd23d5a --- /dev/null +++ b/crates/lspkit-server/src/uri_cases.rs @@ -0,0 +1,244 @@ +//! [URI-WINDOWS] The Windows conversion table from issue #49, kept once and +//! run twice: by `uri_style_tests.rs` against the Windows rules on every OS, +//! and by `tests/uri_windows.rs` through the public API on a Windows build. +//! Test data only; nothing here ships in the library. + +/// A URI, the exact Windows path it decodes to, and the canonical URI that +/// path encodes back to (which decodes to the same path again). +pub(crate) const ROUND_TRIPS: [(&str, &str, &str); 35] = [ + // Drive letters: one URI per drive, the letter upper case. + ( + "file:///C:/repo/a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ( + "file:///c:/repo/a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ( + "file:///C%3A/repo/a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ( + "file:///c%3a/my%20repo/a.rs", + r"C:\my repo\a.rs", + "file:///C:/my%20repo/a.rs", + ), + ("file:///C:/", r"C:\", "file:///C:/"), + ( + "file:///D:/deep/x/y/z/a.rs", + r"D:\deep\x\y\z\a.rs", + "file:///D:/deep/x/y/z/a.rs", + ), + ( + "file://localhost/C:/repo/a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ( + "file://LOCALHOST/C:/repo/a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ("file:///C:/repo/", r"C:\repo\", "file:///C:/repo/"), + ( + "file:///C:/repo/./sub/../a.rs", + r"C:\repo\a.rs", + "file:///C:/repo/a.rs", + ), + ( + "file:///C:/PROGRA~1/a.rs", + r"C:\PROGRA~1\a.rs", + "file:///C:/PROGRA~1/a.rs", + ), + // UNC and network: the host is the server, lower case. + ( + "file://server/share/a.rs", + r"\\server\share\a.rs", + "file://server/share/a.rs", + ), + ( + "file://server/share/", + r"\\server\share\", + "file://server/share/", + ), + ( + "file://server/share", + r"\\server\share", + "file://server/share", + ), + ( + "file:////server/share/a.rs", + r"\\server\share\a.rs", + "file://server/share/a.rs", + ), + ( + "file://SERVER/Share/a.rs", + r"\\server\Share\a.rs", + "file://server/Share/a.rs", + ), + ( + "file://wsl.localhost/Ubuntu/home/a.rs", + r"\\wsl.localhost\Ubuntu\home\a.rs", + "file://wsl.localhost/Ubuntu/home/a.rs", + ), + ( + "file://wsl$/Ubuntu/home/a.rs", + r"\\wsl$\Ubuntu\home\a.rs", + "file://wsl%24/Ubuntu/home/a.rs", + ), + ( + "file://192.168.1.5/share/a.rs", + r"\\192.168.1.5\share\a.rs", + "file://192.168.1.5/share/a.rs", + ), + ( + "file://fe80--1.ipv6-literal.net/share/a.rs", + r"\\fe80--1.ipv6-literal.net\share\a.rs", + "file://fe80--1.ipv6-literal.net/share/a.rs", + ), + ( + "file://[FE80::1%25eth0]/share/a.rs", + r"\\fe80--1seth0.ipv6-literal.net\share\a.rs", + "file://fe80--1seth0.ipv6-literal.net/share/a.rs", + ), + ( + "file://build%2Dhost/share%20one/a.rs", + r"\\build-host\share one\a.rs", + "file://build-host/share%20one/a.rs", + ), + // Names Win32 would rewrite keep the `\\?\` form, so they open the same file. + ( + "file:///C:/repo/name./a.rs", + r"\\?\C:\repo\name.\a.rs", + "file:///C:/repo/name./a.rs", + ), + ( + "file:///C:/repo/name%20/a.rs", + r"\\?\C:\repo\name \a.rs", + "file:///C:/repo/name%20/a.rs", + ), + ( + "file:///C:/repo/NUL", + r"\\?\C:\repo\NUL", + "file:///C:/repo/NUL", + ), + ( + "file:///C:/repo/CON/a.rs", + r"\\?\C:\repo\CON\a.rs", + "file:///C:/repo/CON/a.rs", + ), + ( + "file:///C:/repo/aux.rs", + r"\\?\C:\repo\aux.rs", + "file:///C:/repo/aux.rs", + ), + ( + "file://server/share/name./a.rs", + r"\\?\UNC\server\share\name.\a.rs", + "file://server/share/name./a.rs", + ), + // Characters that must be percent-encoded, and a literal `%20` in a name. + ( + "file:///C:/a%20%23%25%3F%26%2B%3B%3D%40%5B%5D%7B%7D%27%60%5E~/b.rs", + r"C:\a #%?&+;=@[]{}'`^~\b.rs", + "file:///C:/a%20%23%25%3F%26%2B%3B%3D%40%5B%5D%7B%7D%27%60%5E~/b.rs", + ), + ( + "file:///C:/a%2520b.rs", + r"C:\a%20b.rs", + "file:///C:/a%2520b.rs", + ), + ( + "file:///C:/a%252Fb%255Cc.rs", + r"C:\a%2Fb%5Cc.rs", + "file:///C:/a%252Fb%255Cc.rs", + ), + // Unicode: precomposed, CJK, astral, combining mark, right-to-left. + ( + "file:///C:/caf%C3%A9.rs", + "C:\\caf\u{e9}.rs", + "file:///C:/caf%C3%A9.rs", + ), + ( + "file:///C:/%E6%97%A5%E6%9C%AC%E8%AA%9E/%F0%9F%A6%80.rs", + "C:\\\u{65e5}\u{672c}\u{8a9e}\\\u{1f980}.rs", + "file:///C:/%E6%97%A5%E6%9C%AC%E8%AA%9E/%F0%9F%A6%80.rs", + ), + ( + "file:///C:/e%CC%81.rs", + "C:\\e\u{301}.rs", + "file:///C:/e%CC%81.rs", + ), + ( + "file:///C:/%D7%A9%D7%9C%D7%95%D7%9D.rs", + "C:\\\u{5e9}\u{5dc}\u{5d5}\u{5dd}.rs", + "file:///C:/%D7%A9%D7%9C%D7%95%D7%9D.rs", + ), +]; + +/// Windows paths a URI is made from, and the one canonical URI each gets. +pub(crate) const PATHS_TO_URIS: [(&str, &str); 14] = [ + (r"C:/repo\sub/a.rs", "file:///C:/repo/sub/a.rs"), + (r"C:\repo\\double\a.rs", "file:///C:/repo/double/a.rs"), + (r"C:\Repo\a.rs", "file:///C:/Repo/a.rs"), + (r"c:\Repo\a.rs", "file:///C:/Repo/a.rs"), + (r"\\?\C:\repo\a.rs", "file:///C:/repo/a.rs"), + (r"\\?\c:\repo\a.rs", "file:///C:/repo/a.rs"), + (r"\\?\UNC\server\share\a.rs", "file://server/share/a.rs"), + (r"\\?\C:\repo\name.", "file:///C:/repo/name."), + (r"\\server\share\a.rs", "file://server/share/a.rs"), + (r"\\SERVER\share\a.rs", "file://server/share/a.rs"), + (r"\\server\share\", "file://server/share/"), + (r"//server/share/a.rs", "file://server/share/a.rs"), + (r"\\wsl$\Ubuntu\home\a.rs", "file://wsl%24/Ubuntu/home/a.rs"), + ( + r"\\wsl.localhost\Ubuntu\home\a.rs", + "file://wsl.localhost/Ubuntu/home/a.rs", + ), +]; + +/// Windows paths that name no file a URI can reach: device namespaces, +/// volume GUIDs, a server with no share, and paths without a drive root. +pub(crate) const PATHS_REJECTED: [&str; 9] = [ + r"\\.\C:\a.rs", + r"\\?\Volume{00000000-0000-0000-0000-000000000000}\", + r"\\?\GLOBALROOT\Device\x", + r"\\server\", + r"\\.\pipe\name", + r"C:", + r"C:a.rs", + r"\a.rs", + r"repo\a.rs", +]; + +/// URIs that name no absolute Windows path, with the `UriError` variant each +/// is rejected with. None may decode to a relative path or panic. +pub(crate) const URIS_REJECTED: [(&str, &str); 23] = [ + ("file:repo/a.rs", "UnsupportedScheme"), + ("http://x/a.rs", "UnsupportedScheme"), + ("", "UnsupportedScheme"), + ("file://", "NoLocalPath"), + ("file:///", "NoLocalPath"), + ("file:///repo/a.rs", "NoLocalPath"), + ("file:///tmp/a.rs", "NoLocalPath"), + ("file:///C:", "NoLocalPath"), + ("file://server", "NoLocalPath"), + ("file://server/", "NoLocalPath"), + ("file://server:8080/share/a.rs", "NoLocalPath"), + ("file://user@server/share/a.rs", "NoLocalPath"), + ("file://./C:/a.rs", "NoLocalPath"), + ("file://%3F/C:/a.rs", "NoLocalPath"), + ("file:///C:/a%2Fb.rs", "NoLocalPath"), + ("file:///C:/a%5Cb.rs", "NoLocalPath"), + ("file://host%5Cshare%5Cx/a.rs", "NoLocalPath"), + ("file://host%2Fshare/a.rs", "NoLocalPath"), + ("file:///C:/repo/a%2F..%2F..%2Fwindows.rs", "NoLocalPath"), + ("file:///C:/a%ZZ.rs", "InvalidUtf8"), + ("file:///C:/a%", "InvalidUtf8"), + ("file:///C:/a%2", "InvalidUtf8"), + ("file:///C:/%FF%FE.rs", "InvalidUtf8"), +]; diff --git a/crates/lspkit-server/src/uri_style_tests.rs b/crates/lspkit-server/src/uri_style_tests.rs index d577826..8ed5de1 100644 --- a/crates/lspkit-server/src/uri_style_tests.rs +++ b/crates/lspkit-server/src/uri_style_tests.rs @@ -1,80 +1,58 @@ -//! [URI-AUTHORITY] Path-style rules, isolated so the Linux CI runs the Windows -//! rules too: the public functions only take the Windows branch on a Windows build. +//! [URI-AUTHORITY] [URI-WINDOWS] Path-style rules, isolated so the Linux CI +//! runs the Windows rules too: the public functions only take the Windows +//! branch on a Windows build, where `tests/uri_windows.rs` runs the same table. use super::{native_to_uri, uri_to_native, Style, UriError}; -/// URIs, the Windows path each names, and the URI that path encodes back to. -const WINDOWS_ROUND_TRIPS: [(&str, &str, &str); 6] = [ - ( - "file:///C:/repo/a.rs", - r"C:\repo\a.rs", - "file:///C:/repo/a.rs", - ), - ( - "file:///c%3A/my%20repo/a.rs", - r"c:\my repo\a.rs", - "file:///c:/my%20repo/a.rs", - ), - ("file://localhost/D:/a.rs", r"D:\a.rs", "file:///D:/a.rs"), - ( - "file://server/share/a.rs", - r"\\server\share\a.rs", - "file://server/share/a.rs", - ), - ( - "file://build%2Dhost/share%20one/a.rs", - r"\\build-host\share one\a.rs", - "file://build-host/share%20one/a.rs", - ), - ( - "file://wsl.localhost/Ubuntu/home/a.rs", - r"\\wsl.localhost\Ubuntu\home\a.rs", - "file://wsl.localhost/Ubuntu/home/a.rs", - ), -]; - -/// Extended-length paths `std::fs::canonicalize` returns, and their URIs. -const VERBATIM_PATHS: [(&str, &str); 2] = [ - (r"\\?\C:\repo\a.rs", "file:///C:/repo/a.rs"), - (r"\\?\UNC\server\share\a.rs", "file://server/share/a.rs"), -]; - -/// URIs that name no absolute Windows path. -const NO_WINDOWS_PATH: [&str; 4] = [ - "file:///tmp/a.rs", - "file:///C:", - "file://server", - "file://server/", -]; +#[path = "uri_cases.rs"] +mod cases; #[test] -fn windows_uris_decode_to_absolute_drive_and_unc_paths_and_round_trip() { - for (uri, path, encoded) in WINDOWS_ROUND_TRIPS { +fn windows_uris_decode_to_exact_paths_and_round_trip() { + for (uri, path, canonical) in cases::ROUND_TRIPS { let decoded = uri_to_native(uri, Style::Windows).expect("a Windows URI decodes"); assert_eq!(decoded, path, "{uri}"); - assert_eq!(native_to_uri(&decoded, Style::Windows), encoded, "{path}"); - let again = uri_to_native(encoded, Style::Windows).expect("re-decodes"); - assert_eq!(again, path, "{encoded} round-trips"); + assert_eq!( + native_to_uri(&decoded, Style::Windows).as_deref(), + Some(canonical), + "{path}" + ); + let again = uri_to_native(canonical, Style::Windows).expect("re-decodes"); + assert_eq!(again, path, "{canonical} round-trips"); } } #[test] -fn windows_extended_length_prefixes_are_removed_from_uris() { - for (path, uri) in VERBATIM_PATHS { - assert_eq!(native_to_uri(path, Style::Windows), uri, "{path}"); +fn windows_paths_encode_to_one_canonical_uri() { + for (path, uri) in cases::PATHS_TO_URIS { + assert_eq!( + native_to_uri(path, Style::Windows).as_deref(), + Some(uri), + "{path}" + ); let decoded = uri_to_native(uri, Style::Windows).expect("decodes"); - assert!(!decoded.contains('?'), "{uri} decodes without a prefix"); + assert!( + !decoded.contains('/'), + "{uri} decodes with native separators" + ); + } +} + +#[test] +fn windows_device_and_rootless_paths_have_no_uri() { + for path in cases::PATHS_REJECTED { + assert_eq!(native_to_uri(path, Style::Windows), None, "{path}"); } } #[test] fn windows_uris_without_an_absolute_path_are_rejected() { - for uri in NO_WINDOWS_PATH { + for (uri, variant) in cases::URIS_REJECTED { let err = uri_to_native(uri, Style::Windows).expect_err("no absolute path"); - assert!( - matches!(&err, UriError::NoLocalPath(rejected) if rejected == uri), - "{uri}: {err:?}" - ); + assert!(format!("{err:?}").starts_with(variant), "{uri}: {err:?}"); + if let UriError::NoLocalPath(rejected) = &err { + assert_eq!(rejected, uri, "the error names the URI"); + } } } @@ -96,8 +74,8 @@ fn both_styles_share_one_authority_parser() { ); } assert_eq!( - native_to_uri("/tmp/a b.rs", Style::Unix), - "file:///tmp/a%20b.rs" + native_to_uri("/tmp/a b.rs", Style::Unix).as_deref(), + Some("file:///tmp/a%20b.rs") ); for style in [Style::Unix, Style::Windows] { let remote = uri_to_native("file://server/", style).expect_err("no share path"); @@ -107,5 +85,12 @@ fn both_styles_share_one_authority_parser() { matches!(scheme, UriError::UnsupportedScheme(_)), "{style:?}" ); + let encoded = uri_to_native("file:///C:/a%2Fb", style).expect_err("an encoded /"); + assert!(matches!(encoded, UriError::NoLocalPath(_)), "{style:?}"); + let truncated = uri_to_native("file:///C:/a%", style).expect_err("a lone %"); + assert!( + matches!(truncated, UriError::InvalidUtf8(None)), + "{style:?}" + ); } } diff --git a/crates/lspkit-server/tests/uri.rs b/crates/lspkit-server/tests/uri.rs index 9e8a398..2f47943 100644 --- a/crates/lspkit-server/tests/uri.rs +++ b/crates/lspkit-server/tests/uri.rs @@ -80,25 +80,52 @@ fn invalid_percent_encoding_rejected() { } } +/// [URI-WINDOWS] A `%` not followed by two hex digits is malformed on every +/// platform; it is never passed through into the path. #[test] -fn truncated_percent_encoding_passes_through_bytes() { - // Only two-char-followed percents are decoded; a stray `%` near end falls through. - let decoded = uri_to_path("file:///tmp/a%").expect("decoded"); - assert!(decoded.to_string_lossy().contains('%')); +fn truncated_percent_encoding_rejected() { + for uri in ["file:///tmp/a%", "file:///tmp/a%2"] { + let err = uri_to_path(uri).expect_err("must reject"); + assert!(matches!(err, UriError::InvalidUtf8(None)), "{uri}: {err:?}"); + } } #[cfg(not(windows))] #[test] fn lowercase_hex_percent_decodes() { - let decoded = uri_to_path("file:///tmp/a%2fb").expect("decoded"); - assert_eq!(decoded, PathBuf::from("/tmp/a/b")); + let decoded = uri_to_path("file:///tmp/a%2cb%c3%a9").expect("decoded"); + assert_eq!(decoded, PathBuf::from("/tmp/a,b\u{e9}")); } #[cfg(not(windows))] #[test] fn uppercase_hex_percent_decodes() { - let decoded = uri_to_path("file:///tmp/a%2Fb").expect("decoded"); - assert_eq!(decoded, PathBuf::from("/tmp/a/b")); + let decoded = uri_to_path("file:///tmp/a%2Cb%C3%A9").expect("decoded"); + assert_eq!(decoded, PathBuf::from("/tmp/a,b\u{e9}")); +} + +/// [URI-WINDOWS] An encoded `/` stays inside its file name, which no Unix +/// file can hold, so the URI is rejected instead of gaining a folder. +#[cfg(not(windows))] +#[test] +fn encoded_separator_is_rejected_never_split_on() { + for uri in ["file:///tmp/a%2fb", "file:///tmp/a%2Fb"] { + let err = uri_to_path(uri).expect_err("an encoded separator"); + assert!( + matches!(&err, UriError::NoLocalPath(rejected) if rejected == uri), + "{uri}: {err:?}" + ); + } + let backslash = uri_to_path("file:///tmp/a%5Cb").expect("a Unix name may hold a backslash"); + assert_eq!(backslash, PathBuf::from(r"/tmp/a\b")); + let literal = uri_to_path("file:///tmp/a%252Fb").expect("an encoded percent"); + assert_eq!( + literal, + PathBuf::from("/tmp/a%2Fb"), + "decoded once, never twice" + ); + let host = uri_to_path("file://host%2Fshare/a.rs").expect_err("an encoded / in the host"); + assert!(matches!(host, UriError::NoLocalPath(_)), "{host:?}"); } #[test] diff --git a/crates/lspkit-server/tests/uri_authority.rs b/crates/lspkit-server/tests/uri_authority.rs index 216a514..89a756d 100644 --- a/crates/lspkit-server/tests/uri_authority.rs +++ b/crates/lspkit-server/tests/uri_authority.rs @@ -1,6 +1,6 @@ //! [URI-AUTHORITY] Issue #49 through the public API only, so this file also //! compiles against the pre-fix crate and fails there on the exact symptom. -//! Unix-only: the Windows rows live in the Windows-hosted suite. +//! Unix-only: the Windows rows live in `uri_windows.rs`. #![cfg(not(windows))] use std::path::PathBuf; diff --git a/crates/lspkit-server/tests/uri_windows.rs b/crates/lspkit-server/tests/uri_windows.rs new file mode 100644 index 0000000..5b4e0f0 --- /dev/null +++ b/crates/lspkit-server/tests/uri_windows.rs @@ -0,0 +1,265 @@ +//! [URI-WINDOWS] Issue #49's Windows verification plan, through the public +//! API only: `uri_to_path` and `path_to_uri` on a real Windows build, where +//! `cfg(windows)` selects the Windows rules. Only the public functions are +//! used, so this file also compiles against the pre-fix crate. +#![cfg(windows)] + +use std::fmt::Debug; +use std::path::{Path, PathBuf}; +use std::process::Command; + +use lspkit_server::{path_to_uri, uri_to_path}; + +#[path = "../src/uri_cases.rs"] +mod cases; + +/// A failed check, naming the input that failed and why. +type Checked = Result; + +/// Fails with `what` unless `holds`. +fn ensure(holds: bool, what: impl FnOnce() -> String) -> Checked<()> { + if holds { + Ok(()) + } else { + Err(what()) + } +} + +/// Fails with both values and `what` unless they are equal. +fn same(left: T, right: T, what: &str) -> Checked<()> { + ensure(left == right, move || { + format!("{what}\n left: {left:?}\n right: {right:?}") + }) +} + +/// Names a failed filesystem step. +fn io(step: &str, result: std::io::Result) -> Checked { + result.map_err(|err| format!("{step}: {err}")) +} + +/// `uri_to_path`, naming the URI when it is rejected. +fn decode(uri: &str) -> Checked { + uri_to_path(uri).map_err(|err| format!("{uri} decodes: {err:?}")) +} + +/// `path_to_uri`, naming the path when it is rejected. +fn encode(path: &Path) -> Checked { + path_to_uri(path).map_err(|err| format!("{} encodes: {err:?}", path.display())) +} + +/// Decodes `uri`, checks the path is absolute and that its canonical URI +/// decodes to the same path again, and returns the path. +fn round_trip(uri: &str, canonical: &str) -> Checked { + let path = decode(uri)?; + ensure(path.is_absolute(), || { + format!("{uri} decodes to the relative {}", path.display()) + })?; + same(encode(&path)?.as_str(), canonical, uri)?; + same( + decode(canonical)?.as_os_str(), + path.as_os_str(), + &format!("{canonical} round-trips"), + )?; + Ok(path) +} + +#[test] +fn table_uris_decode_to_exact_absolute_paths_and_round_trip() -> Checked<()> { + for (uri, path, canonical) in cases::ROUND_TRIPS { + same( + round_trip(uri, canonical)?.as_os_str(), + std::ffi::OsStr::new(path), + uri, + )?; + } + Ok(()) +} + +#[test] +fn table_paths_encode_to_one_canonical_uri() -> Checked<()> { + for (path, uri) in cases::PATHS_TO_URIS { + same(encode(Path::new(path))?.as_str(), uri, path)?; + let decoded = round_trip(uri, uri)?; + ensure(!decoded.as_os_str().to_string_lossy().contains('/'), || { + format!("{uri} decodes with native separators") + })?; + } + Ok(()) +} + +#[test] +fn table_device_and_rootless_paths_are_errors() { + for path in cases::PATHS_REJECTED { + let result = path_to_uri(Path::new(path)); + assert!(result.is_err(), "{path} gave {result:?}"); + } +} + +#[test] +fn table_uris_without_an_absolute_path_are_errors_never_relative_paths() { + for (uri, variant) in cases::URIS_REJECTED { + let rejected = uri_to_path(uri); + assert!( + rejected + .as_ref() + .is_err_and(|err| format!("{err:?}").starts_with(variant)), + "{uri} must be {variant}, got {rejected:?}" + ); + } +} + +/// A fresh directory, and its path as `std::fs::canonicalize` spells it (`\\?\C:\…`). +fn canonical_temp_dir() -> Checked<(tempfile::TempDir, PathBuf)> { + let dir = io("temp dir", tempfile::tempdir())?; + let canonical = io("canonicalize", std::fs::canonicalize(dir.path()))?; + ensure( + canonical.as_os_str().to_string_lossy().starts_with(r"\\?\"), + || format!("{} is extended-length", canonical.display()), + )?; + Ok((dir, canonical)) +} + +/// Writes `contents` at the canonical `path`, then proves its URI decodes to +/// a path that opens the same file and round-trips. +fn real_file_round_trips(path: &Path, contents: &str) -> Checked<()> { + io("write", std::fs::write(path, contents))?; + let uri = encode(path)?; + ensure(!uri.contains('?') && !uri.contains("%3F"), || { + format!("{uri} keeps no verbatim prefix") + })?; + let decoded = round_trip(&uri, &uri)?; + same( + std::fs::read_to_string(&decoded).ok().as_deref(), + Some(contents), + &format!("{uri} → {} opens the file it names", decoded.display()), + ) +} + +/// A canonical folder's URI decodes to a path that resolves to the same folder. +fn real_dir_round_trips(dir: &Path) -> Checked<()> { + let uri = encode(dir)?; + let decoded = round_trip(&uri, &uri)?; + same( + std::fs::canonicalize(&decoded).ok().as_deref(), + Some(dir), + &format!("{uri} → {}", decoded.display()), + ) +} + +#[test] +fn canonicalized_files_and_folders_round_trip_and_open() -> Checked<()> { + let (_dir, root) = canonical_temp_dir()?; + real_file_round_trips(&root.join("a.rs"), "plain")?; + let spaced = root.join("my repo"); + io("mkdir", std::fs::create_dir(&spaced))?; + real_file_round_trips(&spaced.join("b c.rs"), "spaced")?; + real_file_round_trips( + &root.join("caf\u{e9} \u{65e5}\u{672c} \u{1f980}.rs"), + "unicode", + )?; + real_file_round_trips(&root.join("a #%&+;=@[]{}'`^~ %20.rs"), "reserved")?; + real_dir_round_trips(&root)?; + real_dir_round_trips(&spaced) +} + +#[test] +fn names_win32_would_rewrite_round_trip_and_open_the_same_file() -> Checked<()> { + let (_dir, root) = canonical_temp_dir()?; + for name in [ + "trailing dot.", + "trailing space ", + "aux.rs", + "NUL", + "CON", + "com1.txt", + ] { + real_file_round_trips(&root.join(name), name)?; + } + let folder = root.join("CON"); + io("remove the CON file", std::fs::remove_file(&folder))?; + io("mkdir CON", std::fs::create_dir(&folder))?; + real_file_round_trips(&folder.join("a.rs"), "inside CON")?; + ensure(root.join("NUL").is_file(), || { + "NUL stayed a file, never the device".to_owned() + }) +} + +#[test] +fn a_path_longer_than_max_path_round_trips_and_opens() -> Checked<()> { + let (_dir, root) = canonical_temp_dir()?; + let mut deep = root; + while deep.as_os_str().len() < 300 { + deep.push("a-forty-character-folder-name-0123456789"); + } + io( + "mkdir under the verbatim root", + std::fs::create_dir_all(&deep), + )?; + let file = deep.join("long.rs"); + real_file_round_trips(&file, "long")?; + let uri = encode(&file)?; + ensure(uri.len() > 260, || format!("{uri} is past MAX_PATH")) +} + +#[test] +fn a_junction_round_trips_and_opens_through_its_target() -> Checked<()> { + let (_dir, root) = canonical_temp_dir()?; + let target = root.join("target"); + io("mkdir", std::fs::create_dir(&target))?; + io("write", std::fs::write(target.join("a.rs"), "via junction"))?; + let plain = |path: &Path| { + path.as_os_str() + .to_string_lossy() + .trim_start_matches(r"\\?\") + .to_owned() + }; + let link = root.join("link"); + let mklink = Command::new("cmd") + .args(["/C", "mklink", "/J", &plain(&link), &plain(&target)]) + .output(); + let mklink = io("mklink runs", mklink)?; + ensure(mklink.status.success(), || format!("mklink /J: {mklink:?}"))?; + let through = link.join("a.rs"); + let uri = encode(&through)?; + let decoded = round_trip(&uri, &uri)?; + same( + std::fs::read_to_string(&decoded).ok().as_deref(), + Some("via junction"), + &uri, + )?; + let resolved = io("canonicalize", std::fs::canonicalize(&through))?; + real_file_round_trips(&resolved, "via junction") +} + +#[test] +fn drive_letter_case_never_gives_one_file_two_uris() -> Checked<()> { + let (_dir, root) = canonical_temp_dir()?; + let file = root.join("Case.rs"); + io("write", std::fs::write(&file, "x"))?; + let upper = encode(&file)?; + let text = file.as_os_str().to_string_lossy().into_owned(); + let mut chars = text.trim_start_matches(r"\\?\").chars(); + let drive = chars.next().ok_or("a drive letter")?.to_ascii_lowercase(); + let lower = format!("{drive}{}", chars.as_str()); + ensure(drive.is_ascii_lowercase(), || { + format!("{lower} starts with a lower-case drive") + })?; + same(encode(Path::new(&lower))?.as_str(), upper.as_str(), &lower) +} + +#[test] +fn an_8_3_short_name_round_trips_and_opens() -> Checked<()> { + let uri = encode(Path::new(r"C:\PROGRA~1"))?; + same(uri.as_str(), "file:///C:/PROGRA~1", "8.3 name")?; + let decoded = round_trip(&uri, &uri)?; + let long = io( + "Program Files exists", + std::fs::canonicalize(r"C:\Program Files"), + )?; + same( + std::fs::canonicalize(&decoded).ok().as_deref(), + Some(long.as_path()), + "C:\\PROGRA~1 opens Program Files (8.3 names are on for the system drive)", + )?; + real_dir_round_trips(&long) +} diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index e961c77..c346387 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -95,6 +95,11 @@ pub trait EngineApi: Send + Sync + 'static { - **Position encoding** (`lspkit::vfs::PositionEncoding`): negotiates encoding at `initialize` per LSP 3.17 client capabilities; converts on every read; round-trips byte/char offsets correctly across multi-byte scalars and surrogate pairs. - **URI ↔ `PathBuf`** (`lspkit-server::uri`): handles `file://`, percent-decoding, Windows drive letters, UNC paths, and non-UTF-8 paths. - **[URI-AUTHORITY]** A URI's authority is its host, never a path segment. An empty or `localhost` host names a local path; any other host names a UNC path (`file://server/share/a.rs` ↔ `\\server\share\a.rs`) on Windows and is an error elsewhere. `uri_to_path` never returns a relative path. `path_to_uri` removes the extended-length prefixes `\\?\` and `\\?\UNC\` that `std::fs::canonicalize` adds. + - **[URI-WINDOWS]** All path ↔ URI handling in the lspkit tree lives in `lspkit-server::uri`; nothing else parses or builds a file path from a URI. On Windows one file has one URI, and every URI decodes to one exact, absolute path: + - The drive letter is upper case and the UNC server name lower case, in both directions. Repeated separators collapse, and `.` and `..` resolve lexically without climbing above the drive or share. + - `file:////server/share` (an empty authority before a UNC path) decodes like `file://server/share`. An IPv6 host `[fe80::1%25eth0]` becomes the server `fe80--1seth0.ipv6-literal.net`. + - `uri_to_path` returns the `\\?\` form only when Win32 would otherwise open a different file: a segment ending in `.` or a space, or a DOS device name (`CON`, `NUL`, `aux.rs`, `COM1`). + - These are errors, never a relative path: a URI with no drive or share; a host with a port, userinfo, or the device namespaces `.` and `?`; a `%2F` or `%5C` inside a name; and, on every platform, a `%` not followed by two hex digits. `path_to_uri` rejects device paths (`\\.\…`, `\\?\Volume{…}`, `\\?\GLOBALROOT\…`). - **Cancellation** (`lspkit-server::dispatch`): a `CancellationToken` is plumbed through every request handler and triggered when the client sends `$/cancelRequest`. - **Progress** (`lspkit-server::progress`): wraps LSP `window/workDoneProgress`; the `Progress` sink is a no-op when the client did not advertise the capability. - **Diagnostics bus** (`lspkit-server::diagnostics`): fan-out from one source to LSP `publishDiagnostics` AND MCP resource-updated notifications, atomically per generation. From c7fd4440182b79fa1fe787067bc7632934d65bd1 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:21:40 +1100 Subject: [PATCH 19/39] Deny unused dependencies: drop unused rmp-serde and the unused lspkit-server/lsp-profiler-dotnet workspace entries --- Cargo.lock | 20 -------------------- Cargo.toml | 9 ++++++--- crates/lspkit/Cargo.toml | 1 - docs/specs/lspkit-spec.md | 2 +- 4 files changed, 7 insertions(+), 25 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 41b7b6c..82ebf48 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -588,7 +588,6 @@ dependencies = [ "dashmap", "futures-core", "futures-util", - "rmp-serde", "ropey", "serde", "serde_json", @@ -941,25 +940,6 @@ dependencies = [ "bytemuck", ] -[[package]] -name = "rmp" -version = "0.8.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" -dependencies = [ - "num-traits", -] - -[[package]] -name = "rmp-serde" -version = "1.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" -dependencies = [ - "rmp", - "serde", -] - [[package]] name = "ropey" version = "1.6.1" diff --git a/Cargo.toml b/Cargo.toml index b516149..04d6de8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,6 +22,12 @@ readme = "README.md" keywords = ["lsp", "mcp", "language-server", "tree-sitter", "json-rpc"] categories = ["development-tools"] +# Unused dependencies are dead code: a crate dependency or a +# `[workspace.dependencies]` entry nothing uses fails the build. +[workspace.lints.cargo] +unused_dependencies = "deny" +unused_workspace_dependencies = "deny" + [workspace.lints.rust] unsafe_code = "deny" missing_docs = "deny" @@ -119,7 +125,6 @@ async-trait = "0.1" # Serialization serde = { version = "1", features = ["derive"] } serde_json = "1" -rmp-serde = "1" # LSP protocol types (maintained; we ship our own server loop) lsp-types = "0.97" @@ -157,6 +162,4 @@ stats_alloc = "0.1.10" # Versions are the `0.0.0-dev` placeholder; the release stamps the tag into # both `[workspace.package].version` and these requirements. [SWR-VERSION-BUILD-STAMPING] lspkit = { version = "0.0.0-dev", path = "crates/lspkit" } -lspkit-server = { version = "0.0.0-dev", path = "crates/lspkit-server" } lsp-profiler = { version = "0.0.0-dev", path = "crates/lsp-profiler" } -lsp-profiler-dotnet = { version = "0.0.0-dev", path = "crates/lsp-profiler-dotnet" } diff --git a/crates/lspkit/Cargo.toml b/crates/lspkit/Cargo.toml index 6768c03..5575afe 100644 --- a/crates/lspkit/Cargo.toml +++ b/crates/lspkit/Cargo.toml @@ -23,7 +23,6 @@ workspace = true async-trait.workspace = true dashmap.workspace = true futures-core.workspace = true -rmp-serde.workspace = true ropey.workspace = true serde.workspace = true thiserror.workspace = true diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index c346387..e48988d 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -110,7 +110,7 @@ pub trait EngineApi: Send + Sync + 'static { - `tokio` 1.x, `tracing` + `tracing-subscriber`, `serde` + `serde_derive`, `async-trait`. - `lsp-types` (current major). - `notify` 7.x, `ropey` 1.x, `dashmap` 6.x, `tokio-util` (for `CancellationToken`). -- `rmp-serde` available as the default wire format for `lspkit::sidecar`; transport is generic over `serde`. +- `lspkit::sidecar` carries opaque length-prefixed payloads; the consumer picks the encoding (JSON, MessagePack, CBOR) and its crate. - **No `tower-lsp`.** Ever. ## Public API hygiene From 13c6f8234da30fb15708e3648b04d49bcacbff58 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:23:48 +1100 Subject: [PATCH 20/39] Make lint and the website test pass on a Windows host - lsp-profiler-dotnet: backtick CoreCLR in a cfg(windows) doc comment. Linux CI never compiles that function, so clippy::doc_markdown only fired on Windows. - website/tests/prose_test.py: resolve npm with shutil.which, because CreateProcess cannot find npm.cmd by its bare name. Read pages as UTF-8, not the Windows code page. Co-Authored-By: Claude Opus 5.5 --- crates/lsp-profiler-dotnet/src/process.rs | 2 +- website/tests/prose_test.py | 10 +++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/lsp-profiler-dotnet/src/process.rs b/crates/lsp-profiler-dotnet/src/process.rs index 9c93a68..f842345 100644 --- a/crates/lsp-profiler-dotnet/src/process.rs +++ b/crates/lsp-profiler-dotnet/src/process.rs @@ -163,7 +163,7 @@ pub fn has_endpoint(pid: u32) -> Option { } #[cfg(windows)] -/// Search Windows named pipes for the target's CoreCLR diagnostics endpoint. +/// Search Windows named pipes for the target's `CoreCLR` diagnostics endpoint. fn endpoint_exists(pid: u32) -> Option { let exact = format!("dotnet-diagnostic-{pid}"); let prefixed = format!("{exact}-"); diff --git a/website/tests/prose_test.py b/website/tests/prose_test.py index cf1e0d0..4bb0ecc 100644 --- a/website/tests/prose_test.py +++ b/website/tests/prose_test.py @@ -17,7 +17,7 @@ class Document(HTMLParser): def __init__(self, path): super().__init__() self.elements = [] - self.feed(path.read_text()) + self.feed(path.read_text(encoding="utf-8")) def handle_starttag(self, tag, attrs): self.elements.append((tag, dict(attrs))) @@ -30,7 +30,11 @@ class ProsePages(unittest.TestCase): @classmethod def setUpClass(cls): shutil.rmtree(OUTPUT, ignore_errors=True) - subprocess.run(["npm", "run", "build"], cwd=SITE, check=True) + # npm is npm.cmd on Windows, which CreateProcess only finds by its full name. + npm = shutil.which("npm") + if npm is None: + raise RuntimeError("npm is not on PATH") + subprocess.run([npm, "run", "build"], cwd=SITE, check=True) def check_page(self, path): page = Document(path) @@ -109,7 +113,7 @@ def test_reading_pages_have_header_images_and_explicit_prose_classes(self): self.assertEqual(image["src"], "/assets/images/engine.svg") self.assertEqual((image["width"], image["height"]), ("1440", "600")) css = OUTPUT / "assets/css/styles.css" - self.assertLessEqual(len(css.read_text().splitlines()), 2000) + self.assertLessEqual(len(css.read_text(encoding="utf-8").splitlines()), 2000) def test_journal_has_illustrated_posts_and_docs_journal_and_repo_navigation(self): for path in OUTPUT.rglob("*.html"): From aa25ac50368c8ebe4b54741c87f67c8d356f4665 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:24:58 +1100 Subject: [PATCH 21/39] Cap JSON-RPC frames at MAX_FRAME_BYTES and read bodies incrementally (#53) A hostile Content-Length panicked read_message with capacity overflow and any large claim reserved that much memory up front. FrameTooLarge now rejects it before reading, read_message_within takes a server cap, and memory follows the bytes that arrive. --- crates/lspkit-server/src/jsonrpc.rs | 89 ++++++++++++++----- crates/lspkit-server/tests/jsonrpc.rs | 86 ++++++++++++++++++ .../lspkit-server/tests/jsonrpc_frame_heap.rs | 47 ++++++++++ docs/plans/issue-fix-evidence-21-26-48-49.md | 15 ++++ docs/specs/lspkit-spec.md | 1 + test-support/state.rs | 13 ++- 6 files changed, 225 insertions(+), 26 deletions(-) create mode 100644 crates/lspkit-server/tests/jsonrpc_frame_heap.rs diff --git a/crates/lspkit-server/src/jsonrpc.rs b/crates/lspkit-server/src/jsonrpc.rs index 4b88dcf..93f1e4d 100644 --- a/crates/lspkit-server/src/jsonrpc.rs +++ b/crates/lspkit-server/src/jsonrpc.rs @@ -151,43 +151,88 @@ pub enum FramingError { /// Peer closed the stream. #[error("peer closed the stream")] Closed, + /// The peer claimed a body larger than the cap ([JSONRPC-FRAME-LIMIT]). + #[error("frame of {claimed} bytes exceeds the {max}-byte limit")] + FrameTooLarge { + /// The `Content-Length` the peer sent. + claimed: u64, + /// The cap it exceeded. + max: usize, + }, } -/// Read one Content-Length-framed JSON-RPC message from `reader`. +/// Largest body [`read_message`] accepts: 64 MiB ([JSONRPC-FRAME-LIMIT]). +pub const MAX_FRAME_BYTES: usize = 64 * 1024 * 1024; + +/// Read one Content-Length-framed JSON-RPC message of at most +/// [`MAX_FRAME_BYTES`] from `reader`. /// /// # Errors -/// Returns [`FramingError`] on I/O failure, header parse failure, or invalid JSON. +/// Returns [`FramingError`] on I/O failure, header parse failure, an +/// oversized frame, or invalid JSON. pub async fn read_message(reader: &mut BufReader) -> Result where R: AsyncReadExt + Unpin, { - let mut content_length: Option = None; + read_message_within(reader, MAX_FRAME_BYTES).await +} + +/// [`read_message`] with a server-chosen body cap of `max_bytes`. +/// +/// # Errors +/// As [`read_message`], with [`FramingError::FrameTooLarge`] above `max_bytes`. +pub async fn read_message_within( + reader: &mut BufReader, + max_bytes: usize, +) -> Result +where + R: AsyncReadExt + Unpin, +{ + let claimed = content_length(reader).await?; + let length = usize::try_from(claimed) + .ok() + .filter(|length| *length <= max_bytes) + .ok_or(FramingError::FrameTooLarge { + claimed, + max: max_bytes, + })?; + // Memory follows the bytes that arrive, never the length the peer claims. + let mut body = Vec::new(); + let read = (&mut *reader).take(claimed).read_to_end(&mut body).await?; + if read < length { + return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into()); + } + Ok(serde_json::from_slice(&body)?) +} + +/// Read headers up to the blank line; the `Content-Length` they declare. +async fn content_length(reader: &mut BufReader) -> Result +where + R: AsyncReadExt + Unpin, +{ + let mut content_length = None; let mut line = String::new(); loop { line.clear(); - let read = reader.read_line(&mut line).await?; - if read == 0 { + if reader.read_line(&mut line).await? == 0 { return Err(FramingError::Closed); } - let trimmed = line.trim_end_matches(['\r', '\n']); - if trimmed.is_empty() { - break; - } - if let Some(value) = trimmed.strip_prefix("Content-Length:") { - content_length = Some( - value - .trim() - .parse() - .map_err(|source| FramingError::BadHeader(trimmed.to_owned(), Some(source)))?, - ); + let header = line.trim_end_matches(['\r', '\n']); + if header.is_empty() { + return content_length + .ok_or_else(|| FramingError::BadHeader("missing".to_owned(), None)); } + content_length = declared_length(header)?.or(content_length); } - let length = - content_length.ok_or_else(|| FramingError::BadHeader("missing".to_owned(), None))?; - let mut body = vec![0u8; length]; - let _ = reader.read_exact(&mut body).await?; - let message: Message = serde_json::from_slice(&body)?; - Ok(message) +} + +/// The length a `Content-Length` header declares; other headers declare none. +fn declared_length(header: &str) -> Result, FramingError> { + header + .strip_prefix("Content-Length:") + .map(|value| value.trim().parse()) + .transpose() + .map_err(|source| FramingError::BadHeader(header.to_owned(), Some(source))) } /// Writer half of a JSON-RPC connection, serialized so multiple tasks can send. diff --git a/crates/lspkit-server/tests/jsonrpc.rs b/crates/lspkit-server/tests/jsonrpc.rs index 09712f1..d399b84 100644 --- a/crates/lspkit-server/tests/jsonrpc.rs +++ b/crates/lspkit-server/tests/jsonrpc.rs @@ -1,5 +1,6 @@ //! End-to-end tests for [`lspkit_server::jsonrpc`] framing and types. +use lspkit_server::jsonrpc::{read_message_within, MAX_FRAME_BYTES}; use lspkit_server::{FramingError, JsonRpcError, Message, MessageWriter, RequestId}; use serde_json::{json, Value}; use tokio::io::BufReader; @@ -298,3 +299,88 @@ fn message_clone_preserves_fields() { assert_eq!(cloned.method, msg.method); assert_eq!(cloned.id, msg.id); } + +/// A frame whose header claims `length` bytes and that carries `body`. +fn framed(length: impl std::fmt::Display, body: &[u8]) -> Vec { + let mut raw = format!("Content-Length: {length}\r\n\r\n").into_bytes(); + raw.extend_from_slice(body); + raw +} + +/// A notification whose JSON body is exactly `bytes` long. +fn body_of_exactly(bytes: usize) -> Vec { + let shell = br#"{"jsonrpc":"2.0","method":"x","params":[""]}"#.len(); + let pad = "a".repeat(bytes - shell); + format!(r#"{{"jsonrpc":"2.0","method":"x","params":["{pad}"]}}"#).into_bytes() +} + +/// Decode `raw` under a server-chosen cap of `max` body bytes. +async fn decode_within(raw: Vec, max: usize) -> Result { + read_message_within(&mut BufReader::new(std::io::Cursor::new(raw)), max).await +} + +/// [JSONRPC-FRAME-LIMIT] A hostile or garbled `Content-Length` is an error, +/// never a panic and never an allocation of the claimed size. +#[tokio::test] +async fn oversized_content_length_is_rejected_before_any_body_is_read() { + let over_default = u64::try_from(MAX_FRAME_BYTES).expect("the cap fits u64") + 1; + for claimed in [u64::MAX, over_default] { + let err = decode_err(framed(claimed, b"{}")) + .await + .expect_err("over the cap"); + assert!( + matches!(err, FramingError::FrameTooLarge { claimed: c, max } if c == claimed && max == MAX_FRAME_BYTES), + "{claimed}: {err:?}" + ); + assert_eq!( + err.to_string(), + format!("frame of {claimed} bytes exceeds the {MAX_FRAME_BYTES}-byte limit") + ); + } + let beyond_u64 = decode_err(framed("18446744073709551616", b"{}")) + .await + .expect_err("not a u64"); + assert!( + matches!(beyond_u64, FramingError::BadHeader(..)), + "{beyond_u64:?}" + ); +} + +/// [JSONRPC-FRAME-LIMIT] A cap admits a body of exactly its size, rejects one +/// byte more, and a body shorter than its claim is an unexpected EOF. +#[tokio::test] +async fn a_cap_admits_its_limit_and_rejects_one_byte_more() { + const CAP: usize = 256; + let at_cap = body_of_exactly(CAP); + assert_eq!(at_cap.len(), CAP); + let decoded = decode_within(framed(CAP, &at_cap), CAP) + .await + .expect("a body at the cap decodes"); + assert_eq!(decoded.method.as_deref(), Some("x")); + let over = body_of_exactly(CAP + 1); + let err = decode_within(framed(CAP + 1, &over), CAP) + .await + .expect_err("one byte over the cap"); + assert!( + matches!( + err, + FramingError::FrameTooLarge { + claimed: 257, + max: CAP + } + ), + "{err:?}" + ); + let largest = body_of_exactly(MAX_FRAME_BYTES); + let decoded = decode_ok(framed(MAX_FRAME_BYTES, &largest)) + .await + .expect("a body at the default cap decodes"); + assert_eq!(decoded.method.as_deref(), Some("x")); + let short = decode_within(framed(CAP, b"{}"), CAP) + .await + .expect_err("fewer bytes than claimed"); + assert!( + matches!(&short, FramingError::Io(io) if io.kind() == std::io::ErrorKind::UnexpectedEof), + "{short:?}" + ); +} diff --git a/crates/lspkit-server/tests/jsonrpc_frame_heap.rs b/crates/lspkit-server/tests/jsonrpc_frame_heap.rs new file mode 100644 index 0000000..228be0c --- /dev/null +++ b/crates/lspkit-server/tests/jsonrpc_frame_heap.rs @@ -0,0 +1,47 @@ +//! [JSONRPC-FRAME-LIMIT] [MEM-FIX-SCOPE] A body shorter than its claimed length +//! costs only the bytes that arrived. Single-test binary: the instrumented +//! allocator sees no sibling tests. + +use std::io::{Cursor, ErrorKind}; + +use lspkit_server::jsonrpc::{read_message, MAX_FRAME_BYTES}; +use lspkit_server::{FramingError, Message}; +use tokio::io::BufReader; + +#[path = "../../../test-support/state.rs"] +mod state; + +/// The bytes that actually arrive before the peer hangs up. +const SENT: &[u8] = br#"{"jsonrpc":"2.0","method""#; +/// Far above a short read's real cost, far below the claimed body. +const HEAP_BOUND: usize = 64 * 1024; + +/// One read of a frame claiming the largest allowed body but carrying `SENT`. +fn short_read(runtime: &tokio::runtime::Runtime) -> Result { + let mut raw = format!("Content-Length: {MAX_FRAME_BYTES}\r\n\r\n").into_bytes(); + raw.extend_from_slice(SENT); + runtime.block_on(read_message(&mut BufReader::new(Cursor::new(raw)))) +} + +#[test] +fn a_short_body_allocates_what_arrived_not_what_was_claimed() { + let runtime = tokio::runtime::Builder::new_current_thread() + .build() + .expect("a runtime"); + let mut outcome = None; + let stats = state::heap_change(|| outcome = Some(short_read(&runtime))); + assert!( + stats.bytes_allocated < HEAP_BOUND, + "a {}-byte body claiming {MAX_FRAME_BYTES} allocated {} bytes", + SENT.len(), + stats.bytes_allocated + ); + let err = outcome + .expect("the read ran") + .expect_err("the body is short"); + assert!( + matches!(&err, FramingError::Io(io) if io.kind() == ErrorKind::UnexpectedEof), + "{err:?}" + ); + state::assert_releases_heap(|| drop(short_read(&runtime))); +} diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 46150ef..b19c89e 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -234,3 +234,18 @@ Green, after `git apply fix-48.patch`: Summary [ 0.010s] 3 tests run: 3 passed, 0 skipped Summary [ 0.012s] 12 tests run: 12 passed, 0 skipped ``` + +## #53: an oversized `Content-Length` is an error, never a panic or an up-front allocation + +[JSONRPC-FRAME-LIMIT]. Red against a stub (`read_message_within` existing but ignoring its cap), so the tests compile and fail on behaviour: + +```text +oversized_content_length_is_rejected_before_any_body_is_read ... FAILED + panicked at library/alloc/src/raw_vec/mod.rs:29:5: capacity overflow +a_cap_admits_its_limit_and_rejects_one_byte_more ... FAILED + one byte over the cap: Message { method: Some("x"), .. } +a_short_body_allocates_what_arrived_not_what_was_claimed ... FAILED (tests/jsonrpc_frame_heap.rs) + a 25-byte body claiming 67108864 allocated 67117299 bytes +``` + +Green after the cap check and the incremental `take(..).read_to_end` body read: `tests/jsonrpc.rs` 20/20, `tests/jsonrpc_frame_heap.rs` 1/1 (under 64 KiB allocated, and all of it released). Clippy is clean on the host and on `x86_64-pc-windows-msvc`. diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index e48988d..00cdc55 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -91,6 +91,7 @@ pub trait EngineApi: Send + Sync + 'static { ## Cross-cutting helpers — required behavior - **[SIDECAR-REQUEST-LIFETIME]** Dropping a correlator response future immediately unregisters and frees its response channel without another correlator call or a runtime. Abandoned IDs are no longer pending, so later responses return `UnknownId`; no cancellation tombstones accumulate. `register` returns `PendingResponse`, supporting `Future` and `try_recv`. A receiver holds only a weak registry reference, so it cannot prolong the correlator's lifetime. Inbound readers terminate when both destination receivers close, even without EOF or another frame. +- **[JSONRPC-FRAME-LIMIT]** `read_message` accepts a body of at most `MAX_FRAME_BYTES` (64 MiB); `read_message_within` takes a server-chosen cap. A larger `Content-Length` is `FramingError::FrameTooLarge` before any body byte is read, a length beyond `u64` is `BadHeader`, and the body is read incrementally, so memory follows the bytes that arrive, never the claimed length. A body shorter than its claim is `Io(UnexpectedEof)`. Peer input never panics. - **[LSP-OUTBOUND]** Server→client requests (`lspkit-server::outbound::Outbound`): `request` allocates a numeric JSON-RPC id from the sidecar correlator and returns the request frame plus an `OutboundResponse` future; once ids pass `i64::MAX` it returns `IdsExhausted` instead of reusing a number. `null` params are omitted from the frame. `resolve` routes an inbound response to its waiter as the editor's `result` (absent or `null` is `Value::Null`) or its `JsonRpcError`. Requests and notifications are `NotAResponse`; ids never allocated, already answered or abandoned are `UnknownId`. Dropping a wait unregisters it ([SIDECAR-REQUEST-LIFETIME]). `sidecar::RequestId` rebuilds from its raw wire number with `From`, and `JsonRpcError` implements `Display` and `std::error::Error`. - **Position encoding** (`lspkit::vfs::PositionEncoding`): negotiates encoding at `initialize` per LSP 3.17 client capabilities; converts on every read; round-trips byte/char offsets correctly across multi-byte scalars and surrogate pairs. - **URI ↔ `PathBuf`** (`lspkit-server::uri`): handles `file://`, percent-decoding, Windows drive letters, UNC paths, and non-UTF-8 paths. diff --git a/test-support/state.rs b/test-support/state.rs index 2c86184..ae4b95a 100644 --- a/test-support/state.rs +++ b/test-support/state.rs @@ -1,17 +1,22 @@ //! Direct heap accounting shared by isolated, single-test executables. [MEM-FIX-SCOPE] -use stats_alloc::{Region, StatsAlloc, INSTRUMENTED_SYSTEM}; +use stats_alloc::{Region, Stats, StatsAlloc, INSTRUMENTED_SYSTEM}; use std::alloc::System; /// Each test executable has its own instrumented allocator and no sibling tests. #[global_allocator] static ALLOCATOR: &StatsAlloc = &INSTRUMENTED_SYSTEM; -/// Measure real allocation/deallocation calls before any registry inspection or teardown. -pub(crate) fn assert_releases_heap(operation: impl FnOnce()) { +/// The heap traffic of `operation` alone. +pub(crate) fn heap_change(operation: impl FnOnce()) -> Stats { let region = Region::new(ALLOCATOR); operation(); - let stats = region.change(); + region.change() +} + +/// Measure real allocation/deallocation calls before any registry inspection or teardown. +pub(crate) fn assert_releases_heap(operation: impl FnOnce()) { + let stats = heap_change(operation); assert!( stats.bytes_allocated > 0, "the probe must allocate real heap memory" From 0dc2f045abb938fa48ee8f5d5a4a0409845b22dc Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:26:51 +1100 Subject: [PATCH 22/39] clock: test the 1600 leap row through seconds, because Windows SystemTime starts at 1601 century_leap_rules_hold_before_the_epoch panicked on Windows with "overflow when subtracting duration from SystemTime": Windows SystemTime is FILETIME-based and cannot hold 1600-02-29, so make test stopped fail-fast on the first lsp-profiler test there. rfc3339 now formats through rfc3339_seconds(i128). Every row is checked through the seconds formatter on every OS, and also through SystemTime wherever the platform can represent the instant. No row is dropped. Co-Authored-By: Claude Opus 5.5 --- crates/lsp-profiler/src/clock.rs | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs index 81846c8..c6efbfa 100644 --- a/crates/lsp-profiler/src/clock.rs +++ b/crates/lsp-profiler/src/clock.rs @@ -44,7 +44,13 @@ const MARCH: i128 = 3; /// `time` as RFC 3339 UTC, truncated (floored) to the second. #[must_use] pub fn rfc3339(time: SystemTime) -> String { - let secs = epoch_seconds(time); + rfc3339_seconds(epoch_seconds(time)) +} + +/// Whole seconds since the Unix epoch as RFC 3339 UTC. Kept apart from +/// [`SystemTime`], which cannot hold every instant on every platform: on +/// Windows it starts at 1601-01-01. +fn rfc3339_seconds(secs: i128) -> String { let (year, month, day) = civil(secs.div_euclid(DAY_SECS)); let clock = secs.rem_euclid(DAY_SECS); let (hour, minute, second) = ( @@ -121,8 +127,12 @@ mod tests { #[test] fn century_leap_rules_hold_before_the_epoch() { for (secs, want) in BEFORE_EPOCH { - let instant = UNIX_EPOCH - Duration::from_secs(secs); - assert_eq!(rfc3339(instant), want, "-{secs}s"); + assert_eq!(rfc3339_seconds(-i128::from(secs)), want, "-{secs}s"); + // Windows' SystemTime starts at 1601, so the 1600 row exists + // there only as seconds; elsewhere it goes through SystemTime too. + if let Some(instant) = UNIX_EPOCH.checked_sub(Duration::from_secs(secs)) { + assert_eq!(rfc3339(instant), want, "-{secs}s as SystemTime"); + } } } From 50fa6d110ba401b7bdfde29a4276fe01c8bbebeb Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:28:45 +1100 Subject: [PATCH 23/39] Find the reference binary under cargo 1.100's build-dir layout: search the test executable's ancestors for examples/ --- test-support/reference_program.rs | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/test-support/reference_program.rs b/test-support/reference_program.rs index b69feaa..fc5db07 100644 --- a/test-support/reference_program.rs +++ b/test-support/reference_program.rs @@ -1,6 +1,6 @@ //! Locate exactly the real producer built for this test profile. -use std::path::{Path, PathBuf}; +use std::path::PathBuf; use std::process::Stdio; use std::time::Duration; use tokio::process::{Child, Command}; @@ -24,17 +24,21 @@ pub fn reference_binary() -> Result { } } -/// Resolve the producer in this test executable's exact profile directory. +/// Resolve the producer in this test executable's own profile directory. +/// +/// Cargo's build-dir layout moves test executables (`/deps/` before +/// 1.100, `/build///out/` since), while examples stay in +/// `/examples/`. The nearest ancestor holding the example is the +/// profile, so either layout finds the producer built with this test. fn profile_binary() -> Result { let executable = std::env::current_exe().map_err(|error| error.to_string())?; - let profile = executable - .parent() - .and_then(Path::parent) - .ok_or("test executable has no Cargo profile directory")?; - Ok(profile.join("examples").join(format!( - "diagnostic-reference{}", - std::env::consts::EXE_SUFFIX - ))) + let name = format!("diagnostic-reference{}", std::env::consts::EXE_SUFFIX); + executable + .ancestors() + .skip(1) + .map(|directory| directory.join("examples").join(&name)) + .find(|candidate| candidate.is_file()) + .ok_or_else(|| format!("no examples/{name} above {}", executable.display())) } /// Both test clients use the same actual producer and native stdio setup. From d2a22c42583c598f169d56e816aadca69a1961a2 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:29:58 +1100 Subject: [PATCH 24/39] PullStore::forget: evict one closed document and keep every other memo warm (#52) clear() was the only eviction and dropped every memo, so each didClose made all open tabs re-pull cold. forget(uri) retires the document's Salsa input on the next query and reuses the slot for the next opened document; open/forget cycles free exactly what they allocate. --- crates/lspkit-server/src/pull.rs | 68 ++++++++++- crates/lspkit-server/tests/pull_forget.rs | 111 ++++++++++++++++++ .../lspkit-server/tests/pull_forget_heap.rs | 41 +++++++ docs/plans/issue-fix-evidence-21-26-48-49.md | 16 +++ docs/specs/LSP-PULL-SPEC.md | 22 +++- 5 files changed, 248 insertions(+), 10 deletions(-) create mode 100644 crates/lspkit-server/tests/pull_forget.rs create mode 100644 crates/lspkit-server/tests/pull_forget_heap.rs diff --git a/crates/lspkit-server/src/pull.rs b/crates/lspkit-server/src/pull.rs index 6369822..a384aab 100644 --- a/crates/lspkit-server/src/pull.rs +++ b/crates/lspkit-server/src/pull.rs @@ -123,7 +123,11 @@ fn analyze(db: &dyn DiagnosticDb, document: DocumentInput, workspace: WorkspaceI let _generation = workspace.generation(db); let _version = document.version(db); let _retry = document.retry_revision(db); - db.analyze(document.uri(db)) + match document.uri(db).as_str() { + // A retired slot holds no document: its memo releases the old report. + "" => Ok(Arc::default()), + uri => db.analyze(uri), + } } /// Query state serialized behind one mutex. Diagnostics computation is the only @@ -136,6 +140,9 @@ struct QueryState { workspace: WorkspaceInput, /// Reusable per-document Salsa inputs keyed by canonical URI. documents: HashMap, + /// Forgotten inputs, emptied and reused by the next opened document, so + /// slots never outnumber the documents open at once. [LSP-PULL-FORGET] + retired: Vec, } impl QueryState { @@ -151,15 +158,42 @@ impl QueryState { database, workspace, documents: HashMap::new(), + retired: Vec::new(), + } + } + + /// The input for a newly opened `uri`: a retired slot when one exists. + fn admit(&mut self, uri: &str) -> DocumentInput { + let document = match self.retired.pop() { + Some(retired) => { + let _empty = retired.set_uri(&mut self.database).to(uri.to_owned()); + retired + } + None => DocumentInput::new(&self.database, uri.to_owned(), 0, 0), + }; + let _absent = self.documents.insert(uri.to_owned(), document); + document + } + + /// Retire each closed document: drop its URI and memo, keep its slot. + fn forget(&mut self, uris: &[String]) { + let closed: Vec = uris + .iter() + .filter_map(|uri| self.documents.remove(uri)) + .collect(); + for document in closed { + let _closed_uri = document.set_uri(&mut self.database).to(String::new()); + let _released = analyze(&self.database, document, self.workspace); + self.retired.push(document); } } /// Get or create the document handle, then refresh its editor version. fn document(&mut self, uri: &str, version: i32) -> DocumentInput { - let document = *self - .documents - .entry(uri.to_owned()) - .or_insert_with(|| DocumentInput::new(&self.database, uri.to_owned(), 0, 0)); + let document = match self.documents.get(uri) { + Some(open) => *open, + None => self.admit(uri), + }; if *document.version(&self.database) != version { let _previous_version = document.set_version(&mut self.database).to(version); } @@ -221,6 +255,9 @@ pub struct PullStore { revision: Arc, /// Engine generation feeding Salsa without superseding in-flight snapshots. generation: Arc, + /// Closed URIs the next query retires, so a close never waits behind the + /// compiler. Drained by every query. [LSP-PULL-FORGET] + forgotten: Arc>>, } impl PullStore { @@ -240,6 +277,7 @@ impl PullStore { analyzer, revision: Arc::new(AtomicU64::new(1)), generation: Arc::new(AtomicU64::new(1)), + forgotten: Arc::default(), } } @@ -263,6 +301,23 @@ impl PullStore { Ok(()) } + /// Release one closed document's input and memos; every other memo stays + /// warm and no snapshot is superseded. [LSP-PULL-FORGET] + /// + /// Never waits behind compiler work: the next query retires the document, + /// so a later pull of `uri` recomputes. Forgetting an unknown or already + /// forgotten URI is `Ok`. + /// + /// # Errors + /// Returns an error if the pending-forget lock was poisoned. + pub fn forget(&self, uri: &str) -> Result<(), PullError> { + self.forgotten + .lock() + .map_err(poisoned)? + .push(uri.to_owned()); + Ok(()) + } + /// Supersede in-flight work and invalidate inter-file dependencies. /// /// Editor/input changes advance both counters. The pending Salsa generation @@ -327,6 +382,9 @@ impl PullStore { uncancelled(cancel)?; let shared = Arc::clone(&*self.query.lock().map_err(poisoned)?); let mut query = shared.lock().map_err(poisoned)?; + query.forget(&std::mem::take( + &mut *self.forgotten.lock().map_err(poisoned)?, + )); let revision = self.query_revision(&shared)?; let generation = self.generation.load(Ordering::Acquire); let report = query.compute(uri, version, revision, generation, cancel)?; diff --git a/crates/lspkit-server/tests/pull_forget.rs b/crates/lspkit-server/tests/pull_forget.rs new file mode 100644 index 0000000..9194c77 --- /dev/null +++ b/crates/lspkit-server/tests/pull_forget.rs @@ -0,0 +1,111 @@ +//! [LSP-PULL-FORGET] Closing one document releases only its memos: every other +//! open document stays warm, and the closed one recomputes when reopened. +#![cfg(feature = "pull")] + +use std::collections::HashMap; +use std::sync::{Arc, Mutex}; + +use lsp_types::Diagnostic; +use lspkit_server::pull::PullStore; + +/// Compiler calls per URI. +type Calls = Arc>>; + +const A: &str = "file:///repo/a.cs"; +const B: &str = "file:///repo/b.cs"; +const C: &str = "file:///repo/c.cs"; +const D: &str = "file:///repo/d.cs"; + +/// A store whose compiler reports one diagnostic naming the URI it analyzed. +fn counting_store() -> (PullStore, Calls) { + let calls: Calls = Arc::default(); + let counted = Arc::clone(&calls); + let store = PullStore::new(Arc::new(move |uri| { + if let Ok(mut calls) = counted.lock() { + *calls.entry(uri.to_owned()).or_default() += 1; + } + let named = Diagnostic { + message: uri.to_owned(), + ..Diagnostic::default() + }; + Ok(Arc::new(vec![named])) + })); + (store, calls) +} + +/// How many times the compiler analyzed `uri`. +fn calls_for(calls: &Calls, uri: &str) -> usize { + let counts = match calls.lock() { + Ok(counts) => counts, + Err(poisoned) => poisoned.into_inner(), + }; + match counts.get(uri) { + Some(count) => *count, + None => 0, + } +} + +/// Pull `uri` and assert the report names it, never another document. +fn pull(store: &PullStore, uri: &str) -> String { + let pulled = store.diagnostics(uri, 1); + assert!(pulled.is_ok(), "{uri}: {pulled:?}"); + let Ok(report) = pulled else { + return String::new(); + }; + let messages: Vec<&str> = report + .items + .iter() + .map(|item| item.message.as_str()) + .collect(); + assert_eq!(messages, [uri], "{uri} reports only its own diagnostics"); + report.result_id +} + +#[test] +fn forgetting_one_document_keeps_every_other_memo_warm() { + let (store, calls) = counting_store(); + let [_id_a, id_b, id_c] = [A, B, C].map(|uri| pull(&store, uri)); + for uri in [A, B, C] { + let _warm = pull(&store, uri); + assert_eq!(calls_for(&calls, uri), 1, "{uri} is memoized"); + } + let revision = store.revision(); + store.forget(A).expect("forget a closed document"); + assert_eq!(store.revision(), revision, "forgetting supersedes nothing"); + for (uri, id) in [(B, id_b), (C, id_c)] { + assert_eq!(pull(&store, uri), id, "{uri} keeps its snapshot"); + assert_eq!(calls_for(&calls, uri), 1, "{uri} stays a cache hit"); + } + let _reopened = pull(&store, A); + assert_eq!(calls_for(&calls, A), 2, "a forgotten document recomputes"); + let _memo = pull(&store, A); + assert_eq!(calls_for(&calls, A), 2, "and is memoized again"); +} + +#[test] +fn forget_is_idempotent_and_a_recycled_input_never_replays_old_truth() { + let (store, calls) = counting_store(); + for uri in [A, B, C] { + let _first = pull(&store, uri); + } + store + .forget("file:///never/opened.cs") + .expect("an unknown URI"); + store.forget(B).expect("first forget"); + store.forget(B).expect("a repeated forget"); + let _fresh = pull(&store, D); + assert_eq!( + calls_for(&calls, D), + 1, + "a new document computes its own truth" + ); + let _back = pull(&store, B); + assert_eq!(calls_for(&calls, B), 2, "B recomputes after its forget"); + for uri in [A, C] { + let _warm = pull(&store, uri); + assert_eq!(calls_for(&calls, uri), 1, "{uri} never recomputed"); + } + store.clear().expect("clear still drops everything"); + let _cold = pull(&store, C); + assert_eq!(calls_for(&calls, C), 2, "clear recomputes every document"); +} diff --git a/crates/lspkit-server/tests/pull_forget_heap.rs b/crates/lspkit-server/tests/pull_forget_heap.rs new file mode 100644 index 0000000..b9277ae --- /dev/null +++ b/crates/lspkit-server/tests/pull_forget_heap.rs @@ -0,0 +1,41 @@ +//! [LSP-PULL-FORGET] [MEM-FIX-SCOPE] Open/forget cycles of distinct URIs leave +//! no heap behind. Single-test binary: the instrumented allocator sees no +//! sibling tests. +#![cfg(feature = "pull")] + +use std::sync::Arc; + +use lspkit_server::pull::{PullError, PullStore}; + +#[path = "../../../test-support/state.rs"] +mod state; + +/// Cycles that size every reusable buffer before measurement. +const WARM_CYCLES: usize = 1_000; +/// Measured cycles, each on a URI never seen before. +const CYCLES: usize = 1_000; + +/// Open, pull and close `count` distinct documents starting at `first`. +fn cycles(store: &PullStore, first: usize, count: usize) -> Result<(), PullError> { + (first..first + count).try_for_each(|index| { + // One width for every URI: Salsa frees a replaced memo one revision + // late, so equal sizes keep that one-cycle lag byte-neutral. + let uri = format!("file:///repo/doc-{index:06}.cs"); + let _report = store.diagnostics(&uri, 1)?; + store.forget(&uri) + }) +} + +#[test] +fn open_forget_cycles_of_distinct_uris_release_their_heap() { + let store = PullStore::new(Arc::new(|uri| { + Ok(Arc::new(vec![lsp_types::Diagnostic { + message: uri.repeat(16), + ..lsp_types::Diagnostic::default() + }])) + })); + cycles(&store, 0, WARM_CYCLES).expect("warm-up cycles"); + let mut outcome = Ok(()); + state::assert_releases_heap(|| outcome = cycles(&store, WARM_CYCLES, CYCLES)); + outcome.expect("measured cycles"); +} diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index b19c89e..e1881b3 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -249,3 +249,19 @@ a_short_body_allocates_what_arrived_not_what_was_claimed ... FAILED (tests/jso ``` Green after the cap check and the incremental `take(..).read_to_end` body read: `tests/jsonrpc.rs` 20/20, `tests/jsonrpc_frame_heap.rs` 1/1 (under 64 KiB allocated, and all of it released). Clippy is clean on the host and on `x86_64-pc-windows-msvc`. + +## #52: closing one document keeps every other memo warm + +[LSP-PULL-FORGET]. Red against a stub `forget` that returns `Ok(())` and does nothing: + +```text +forgetting_one_document_keeps_every_other_memo_warm ... FAILED + a forgotten document recomputes left: 1 right: 2 +forget_is_idempotent_and_a_recycled_input_never_replays_old_truth ... FAILED + B recomputes after its forget left: 1 right: 2 +open_forget_cycles_of_distinct_uris_release_their_heap ... FAILED (tests/pull_forget_heap.rs) + completed work still retains heap bytes: allocations 12089, deallocations 4072, + bytes_allocated 1439392, bytes_deallocated 334016 +``` + +Green with retired-slot reuse: `pull_forget` 2/2 (B and C remain cache hits with unchanged result ids, A recomputes once, a recycled slot reports only its new URI), `pull_forget_heap` 1/1 (1000 distinct open/forget cycles, 17000 allocations and 17000 deallocations, equal bytes), and `pull_store` 4/4. Disabling `forget` again turns all three red. diff --git a/docs/specs/LSP-PULL-SPEC.md b/docs/specs/LSP-PULL-SPEC.md index 018a884..18716fc 100644 --- a/docs/specs/LSP-PULL-SPEC.md +++ b/docs/specs/LSP-PULL-SPEC.md @@ -17,11 +17,23 @@ identity of the same snapshot that produced its diagnostics. Document versions and workspace revisions invalidate the tracked query. Closing a document must release its retained inputs and diagnostic memos while -the connection stays alive. `PullStore::clear` discards the complete Salsa database -because Salsa input slots cannot be deleted individually. Consumers call it on -`didClose` or an equivalent scope eviction. Other documents recompute under the -advanced workspace identity. Active queries retain discarded storage only until -they finish; they return superseded. Clearing never waits behind compiler work. +the connection stays alive. Consumers call `PullStore::forget(uri)` on `didClose` +([LSP-PULL-FORGET]). `PullStore::clear` discards the complete Salsa database for +a scope eviction such as a solution switch; other documents then recompute under +the advanced workspace identity. Active queries retain discarded storage only +until they finish; they return superseded. Clearing never waits behind compiler work. + +## [LSP-PULL-FORGET] Per-Document Eviction + +`PullStore::forget(uri)` releases one closed document. Every other document's memo +stays warm, and no snapshot is superseded. Salsa input slots cannot be deleted, so +the next query retires the document's input: its URI is emptied, its memo is +recomputed to an empty report (the analyzer never sees a retired slot), and the +slot is reused by the next newly opened document. Slots therefore never outnumber +the documents open at once, and open/forget cycles of distinct URIs free exactly +the heap they allocate. `forget` queues the URI behind its own lock, so a close +never waits behind compiler work. A later pull of a forgotten URI recomputes. +Forgetting an unknown or already forgotten URI is `Ok`. ## [LSP-PULL-CONCURRENCY] Nonblocking Invalidation From 244650ba8f6e45ef152b5badb6d918dc5d380310 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:32:00 +1100 Subject: [PATCH 25/39] Cap the JSON-RPC header block at MAX_HEADER_BYTES (#53) read_line had no bound, so a header line that never ends grew memory with the peer's bytes. One 8 KiB budget now covers every header line and terminator, so an endless line and endless short lines both end in HeaderTooLarge. --- crates/lspkit-server/src/jsonrpc.rs | 32 +- crates/lspkit-server/tests/jsonrpc.rs | 48 ++- .../lspkit-server/tests/jsonrpc_frame_heap.rs | 23 +- docs/plans/issue-fix-evidence-21-26-48-49.md | 13 + docs/specs/lspkit-spec.md | 2 +- website/_site/assets/css/styles.css | 198 +++++++++ .../_site/assets/images/apple-touch-icon.png | Bin 0 -> 17511 bytes website/_site/assets/images/engine.svg | 32 ++ .../images/examples/osprey-flamegraph.webp | Bin 0 -> 55720 bytes .../images/examples/osprey-heatmap.webp | Bin 0 -> 50656 bytes website/_site/assets/images/favicon.ico | Bin 0 -> 15086 bytes website/_site/assets/images/logo.png | Bin 0 -> 109605 bytes website/_site/assets/images/readme-hero.svg | 47 +++ .../blog/categories/field-notes/index.html | 254 ++++++++++++ website/_site/blog/categories/index.html | 229 ++++++++++ website/_site/blog/index.html | 236 +++++++++++ website/_site/blog/one-engine/index.html | 321 ++++++++++++++ website/_site/blog/tags/index.html | 244 +++++++++++ .../tags/language-server-protocol/index.html | 254 ++++++++++++ website/_site/blog/tags/mcp-server/index.html | 254 ++++++++++++ website/_site/blog/tags/rust/index.html | 254 ++++++++++++ .../blog/tags/vscode-extension/index.html | 254 ++++++++++++ website/_site/docs/crates/index.html | 392 ++++++++++++++++++ website/_site/docs/examples/index.html | 343 +++++++++++++++ website/_site/docs/getting-started/index.html | 364 ++++++++++++++++ website/_site/docs/index.html | 346 ++++++++++++++++ website/_site/docs/profiler/index.html | 350 ++++++++++++++++ website/_site/feed.xml | 18 + website/_site/index.html | 259 ++++++++++++ website/_site/llms.txt | 27 ++ website/_site/robots.txt | 60 +++ website/_site/sitemap.xml | 75 ++++ website/_site/techdoc/css/layout.css | 243 +++++++++++ website/_site/techdoc/css/reset.css | 41 ++ website/_site/techdoc/css/utilities.css | 58 +++ website/_site/techdoc/js/language-switcher.js | 31 ++ website/_site/techdoc/js/main.js | 25 ++ website/_site/techdoc/js/mobile-menu.js | 29 ++ website/_site/techdoc/js/theme-toggle.js | 26 ++ 39 files changed, 5376 insertions(+), 6 deletions(-) create mode 100644 website/_site/assets/css/styles.css create mode 100644 website/_site/assets/images/apple-touch-icon.png create mode 100644 website/_site/assets/images/engine.svg create mode 100644 website/_site/assets/images/examples/osprey-flamegraph.webp create mode 100644 website/_site/assets/images/examples/osprey-heatmap.webp create mode 100644 website/_site/assets/images/favicon.ico create mode 100644 website/_site/assets/images/logo.png create mode 100644 website/_site/assets/images/readme-hero.svg create mode 100644 website/_site/blog/categories/field-notes/index.html create mode 100644 website/_site/blog/categories/index.html create mode 100644 website/_site/blog/index.html create mode 100644 website/_site/blog/one-engine/index.html create mode 100644 website/_site/blog/tags/index.html create mode 100644 website/_site/blog/tags/language-server-protocol/index.html create mode 100644 website/_site/blog/tags/mcp-server/index.html create mode 100644 website/_site/blog/tags/rust/index.html create mode 100644 website/_site/blog/tags/vscode-extension/index.html create mode 100644 website/_site/docs/crates/index.html create mode 100644 website/_site/docs/examples/index.html create mode 100644 website/_site/docs/getting-started/index.html create mode 100644 website/_site/docs/index.html create mode 100644 website/_site/docs/profiler/index.html create mode 100644 website/_site/feed.xml create mode 100644 website/_site/index.html create mode 100644 website/_site/llms.txt create mode 100644 website/_site/robots.txt create mode 100644 website/_site/sitemap.xml create mode 100644 website/_site/techdoc/css/layout.css create mode 100644 website/_site/techdoc/css/reset.css create mode 100644 website/_site/techdoc/css/utilities.css create mode 100644 website/_site/techdoc/js/language-switcher.js create mode 100644 website/_site/techdoc/js/main.js create mode 100644 website/_site/techdoc/js/mobile-menu.js create mode 100644 website/_site/techdoc/js/theme-toggle.js diff --git a/crates/lspkit-server/src/jsonrpc.rs b/crates/lspkit-server/src/jsonrpc.rs index 93f1e4d..135e9b5 100644 --- a/crates/lspkit-server/src/jsonrpc.rs +++ b/crates/lspkit-server/src/jsonrpc.rs @@ -159,8 +159,16 @@ pub enum FramingError { /// The cap it exceeded. max: usize, }, + /// The header block ran past [`MAX_HEADER_BYTES`] without its blank line + /// ([JSONRPC-FRAME-LIMIT]). + #[error("header block exceeds the {MAX_HEADER_BYTES}-byte limit")] + HeaderTooLarge, } +/// Largest header block, every line and its terminator included: 8 KiB. It +/// bounds both one endless line and endless short lines ([JSONRPC-FRAME-LIMIT]). +pub const MAX_HEADER_BYTES: u64 = 8 * 1024; + /// Largest body [`read_message`] accepts: 64 MiB ([JSONRPC-FRAME-LIMIT]). pub const MAX_FRAME_BYTES: usize = 64 * 1024 * 1024; @@ -212,11 +220,10 @@ where { let mut content_length = None; let mut line = String::new(); + let mut budget = MAX_HEADER_BYTES; loop { line.clear(); - if reader.read_line(&mut line).await? == 0 { - return Err(FramingError::Closed); - } + budget = header_line(reader, budget, &mut line).await?; let header = line.trim_end_matches(['\r', '\n']); if header.is_empty() { return content_length @@ -226,6 +233,25 @@ where } } +/// Read one header line into `line` from what is left of the header budget; +/// returns the budget that remains. Memory never passes [`MAX_HEADER_BYTES`]. +async fn header_line( + reader: &mut BufReader, + budget: u64, + line: &mut String, +) -> Result +where + R: AsyncReadExt + Unpin, +{ + let mut bounded = (&mut *reader).take(budget); + let read = bounded.read_line(line).await?; + match (read, line.ends_with('\n'), bounded.limit()) { + (_, false, 0) => Err(FramingError::HeaderTooLarge), + (0, _, _) => Err(FramingError::Closed), + (_, _, left) => Ok(left), + } +} + /// The length a `Content-Length` header declares; other headers declare none. fn declared_length(header: &str) -> Result, FramingError> { header diff --git a/crates/lspkit-server/tests/jsonrpc.rs b/crates/lspkit-server/tests/jsonrpc.rs index d399b84..de04e34 100644 --- a/crates/lspkit-server/tests/jsonrpc.rs +++ b/crates/lspkit-server/tests/jsonrpc.rs @@ -1,6 +1,6 @@ //! End-to-end tests for [`lspkit_server::jsonrpc`] framing and types. -use lspkit_server::jsonrpc::{read_message_within, MAX_FRAME_BYTES}; +use lspkit_server::jsonrpc::{read_message_within, MAX_FRAME_BYTES, MAX_HEADER_BYTES}; use lspkit_server::{FramingError, JsonRpcError, Message, MessageWriter, RequestId}; use serde_json::{json, Value}; use tokio::io::BufReader; @@ -384,3 +384,49 @@ async fn a_cap_admits_its_limit_and_rejects_one_byte_more() { "{short:?}" ); } + +/// [`MAX_HEADER_BYTES`] as a length; the test checks the two agree. +const HEADER_CAP: usize = 8 * 1024; + +/// [JSONRPC-FRAME-LIMIT] An endless header line, or endless short header +/// lines, end in `HeaderTooLarge`; a block of exactly the cap still decodes. +#[tokio::test] +async fn header_blocks_past_the_cap_are_rejected_and_one_at_the_cap_decodes() { + assert_eq!(u64::try_from(HEADER_CAP), Ok(MAX_HEADER_BYTES)); + let endless_line = format!("Content-Length: 2\r\nX-Junk: {}", "A".repeat(HEADER_CAP)); + let many_lines = format!("Content-Length: 2\r\n{}", "X: y\r\n".repeat(HEADER_CAP)); + for (name, raw) in [ + ("one endless line", endless_line), + ("endless short lines", many_lines), + ] { + let err = decode_err(raw.into_bytes()) + .await + .expect_err("past the header cap"); + assert!( + matches!(err, FramingError::HeaderTooLarge), + "{name}: {err:?}" + ); + assert_eq!( + err.to_string(), + format!("header block exceeds the {MAX_HEADER_BYTES}-byte limit") + ); + } + let head = "Content-Length: 2\r\nX-Pad: "; + let tail = "\r\n\r\n"; + let pad = "p".repeat(HEADER_CAP - head.len() - tail.len()); + let at_cap = format!("{head}{pad}{tail}"); + assert_eq!(at_cap.len(), HEADER_CAP); + let mut raw = at_cap.clone().into_bytes(); + raw.extend_from_slice(b"{}"); + let decoded = decode_err(raw).await; + assert!( + matches!(&decoded, Err(FramingError::BadJson(_))), + "a header block at the cap is read in full and reaches the body: {decoded:?}" + ); + let mut over = format!("{head}{pad}p{tail}").into_bytes(); + over.extend_from_slice(b"{}"); + let err = decode_err(over) + .await + .expect_err("one byte over the header cap"); + assert!(matches!(err, FramingError::HeaderTooLarge), "{err:?}"); +} diff --git a/crates/lspkit-server/tests/jsonrpc_frame_heap.rs b/crates/lspkit-server/tests/jsonrpc_frame_heap.rs index 228be0c..4500bc3 100644 --- a/crates/lspkit-server/tests/jsonrpc_frame_heap.rs +++ b/crates/lspkit-server/tests/jsonrpc_frame_heap.rs @@ -4,7 +4,7 @@ use std::io::{Cursor, ErrorKind}; -use lspkit_server::jsonrpc::{read_message, MAX_FRAME_BYTES}; +use lspkit_server::jsonrpc::{read_message, MAX_FRAME_BYTES, MAX_HEADER_BYTES}; use lspkit_server::{FramingError, Message}; use tokio::io::BufReader; @@ -16,6 +16,14 @@ const SENT: &[u8] = br#"{"jsonrpc":"2.0","method""#; /// Far above a short read's real cost, far below the claimed body. const HEAP_BOUND: usize = 64 * 1024; +/// An endless header line: 64 header caps of `A` and no newline. +const ENDLESS_HEADER_BYTES: usize = 64 * 8 * 1024; + +/// One read of `raw`, a header line that never ends; the caller owns its bytes. +fn endless_header(runtime: &tokio::runtime::Runtime, raw: &[u8]) -> Result { + runtime.block_on(read_message(&mut BufReader::new(raw))) +} + /// One read of a frame claiming the largest allowed body but carrying `SENT`. fn short_read(runtime: &tokio::runtime::Runtime) -> Result { let mut raw = format!("Content-Length: {MAX_FRAME_BYTES}\r\n\r\n").into_bytes(); @@ -44,4 +52,17 @@ fn a_short_body_allocates_what_arrived_not_what_was_claimed() { "{err:?}" ); state::assert_releases_heap(|| drop(short_read(&runtime))); + + let raw = vec![b'A'; ENDLESS_HEADER_BYTES]; + let mut header = None; + let stats = state::heap_change(|| header = Some(endless_header(&runtime, &raw))); + assert!( + stats.bytes_allocated < HEAP_BOUND, + "a {ENDLESS_HEADER_BYTES}-byte header line under a {MAX_HEADER_BYTES}-byte cap allocated {} bytes", + stats.bytes_allocated + ); + let err = header + .expect("the read ran") + .expect_err("the header never ends"); + assert!(matches!(err, FramingError::HeaderTooLarge), "{err:?}"); } diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index e1881b3..0f6d026 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -265,3 +265,16 @@ open_forget_cycles_of_distinct_uris_release_their_heap ... FAILED (tests/pull_ ``` Green with retired-slot reuse: `pull_forget` 2/2 (B and C remain cache hits with unchanged result ids, A recomputes once, a recycled slot reports only its new URI), `pull_forget_heap` 1/1 (1000 distinct open/forget cycles, 17000 allocations and 17000 deallocations, equal bytes), and `pull_store` 4/4. Disabling `forget` again turns all three red. + +### #53 follow-up: the header block is capped too + +DeslopClaude1 measured 544 MB RSS for a 512 MiB header line with no newline at `0dc2f04`. The red came from stub `HeaderTooLarge` and `MAX_HEADER_BYTES` items that nothing enforced: + +```text +header_blocks_past_the_cap_are_rejected_and_one_at_the_cap_decodes ... FAILED + one endless line: Closed +a_short_body_allocates_what_arrived_not_what_was_claimed ... FAILED (tests/jsonrpc_frame_heap.rs) + a 524288-byte header line under a 8192-byte cap allocated 1056768 bytes +``` + +Green once every header line is read through `take(budget)`: `tests/jsonrpc.rs` 21/21 and `jsonrpc_frame_heap` 1/1, each under 64 KiB. The test covers one endless line, endless `X: y` lines, a block exactly at the cap reaching the body, and one byte over it. diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 00cdc55..434c6ff 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -91,7 +91,7 @@ pub trait EngineApi: Send + Sync + 'static { ## Cross-cutting helpers — required behavior - **[SIDECAR-REQUEST-LIFETIME]** Dropping a correlator response future immediately unregisters and frees its response channel without another correlator call or a runtime. Abandoned IDs are no longer pending, so later responses return `UnknownId`; no cancellation tombstones accumulate. `register` returns `PendingResponse`, supporting `Future` and `try_recv`. A receiver holds only a weak registry reference, so it cannot prolong the correlator's lifetime. Inbound readers terminate when both destination receivers close, even without EOF or another frame. -- **[JSONRPC-FRAME-LIMIT]** `read_message` accepts a body of at most `MAX_FRAME_BYTES` (64 MiB); `read_message_within` takes a server-chosen cap. A larger `Content-Length` is `FramingError::FrameTooLarge` before any body byte is read, a length beyond `u64` is `BadHeader`, and the body is read incrementally, so memory follows the bytes that arrive, never the claimed length. A body shorter than its claim is `Io(UnexpectedEof)`. Peer input never panics. +- **[JSONRPC-FRAME-LIMIT]** `read_message` accepts a body of at most `MAX_FRAME_BYTES` (64 MiB); `read_message_within` takes a server-chosen cap. A larger `Content-Length` is `FramingError::FrameTooLarge` before any body byte is read, a length beyond `u64` is `BadHeader`, and the body is read incrementally, so memory follows the bytes that arrive, never the claimed length. A body shorter than its claim is `Io(UnexpectedEof)`. The header block, every line and terminator included, is read through one `MAX_HEADER_BYTES` (8 KiB) budget, so one endless line and endless short lines both end in `HeaderTooLarge` with memory bounded by the cap. Peer input never panics. - **[LSP-OUTBOUND]** Server→client requests (`lspkit-server::outbound::Outbound`): `request` allocates a numeric JSON-RPC id from the sidecar correlator and returns the request frame plus an `OutboundResponse` future; once ids pass `i64::MAX` it returns `IdsExhausted` instead of reusing a number. `null` params are omitted from the frame. `resolve` routes an inbound response to its waiter as the editor's `result` (absent or `null` is `Value::Null`) or its `JsonRpcError`. Requests and notifications are `NotAResponse`; ids never allocated, already answered or abandoned are `UnknownId`. Dropping a wait unregisters it ([SIDECAR-REQUEST-LIFETIME]). `sidecar::RequestId` rebuilds from its raw wire number with `From`, and `JsonRpcError` implements `Display` and `std::error::Error`. - **Position encoding** (`lspkit::vfs::PositionEncoding`): negotiates encoding at `initialize` per LSP 3.17 client capabilities; converts on every read; round-trips byte/char offsets correctly across multi-byte scalars and surrogate pairs. - **URI ↔ `PathBuf`** (`lspkit-server::uri`): handles `file://`, percent-decoding, Windows drive letters, UNC paths, and non-UTF-8 paths. diff --git a/website/_site/assets/css/styles.css b/website/_site/assets/css/styles.css new file mode 100644 index 0000000..b8ea5cd --- /dev/null +++ b/website/_site/assets/css/styles.css @@ -0,0 +1,198 @@ +/* [WEB-DESIGN-COLOR] Fieldwork tokens; structural layout comes from techdoc. */ +:root { + color-scheme: light; + --color-bg: #f4f1e9; + --color-text: #202720; + --color-primary: #ad321e; + --color-border: #c9ccbf; + --color-muted: #60665b; + --color-panel: #e8ebdf; + --max-width: 1200px; + --content-width: 68ch; + --header-height: 89px; + --font-mono: "SFMono-Regular", Consolas, monospace; +} +[data-theme="dark"] { + color-scheme: dark; + --color-bg: #191c19; + --color-text: #f4f1e9; + --color-primary: #ff997f; + --color-border: #454b41; + --color-muted: #b3b9ac; + --color-panel: #252c24; +} +/* [WEB-DESIGN-TYPE] Local fonts, no network font dependencies. */ +body { background: var(--color-bg); color: var(--color-text); font: 18px/1.7 Arial, Helvetica, sans-serif; } +a { color: inherit; text-underline-offset: 5px; } +a:hover { color: var(--color-primary); } +button { color: inherit; cursor: pointer; } +::selection { color: var(--color-bg); background: var(--color-text); } +:focus-visible { outline: 3px solid var(--color-primary); outline-offset: 5px; } +h1, h2, h3, p, figure { margin: 0; } +h1, h2, h3 { text-wrap: balance; } +h1 { font-size: clamp(40px, 5.5vw, 72px); line-height: 1.05; letter-spacing: -.05em; } +h2 { font-size: clamp(28px, 3.5vw, 44px); line-height: 1.12; letter-spacing: -.04em; } +h3 { font-size: 25px; line-height: 1.25; letter-spacing: -.025em; } +/* [WEB-DESIGN-COMPONENTS] Shared masthead and footer. */ +.site-header { background: var(--color-bg); border-bottom: 1px solid var(--color-border); } +.nav { min-height: var(--header-height); padding: 20px 32px; } +.logo { display: flex; align-items: center; gap: 12px; font-size: 29px; font-weight: 800; letter-spacing: -.06em; text-decoration: none; } +.logo::before { content: ""; flex: 0 0 44px; width: 44px; height: 44px; background: url("/assets/images/logo.png") center / contain no-repeat; } +[data-theme="dark"] .logo::before { background-color: #f4f1e9; background-size: 40px; border-radius: 6px; } +.nav-links { margin-left: auto; gap: 32px; } +.nav-link { display: inline-flex; min-height: 44px; align-items: center; font-size: 14px; text-decoration: none; } +.nav-link.active { color: var(--color-primary); text-decoration: underline; } +.nav-actions { margin-left: 24px; } +.theme-toggle { display: grid; place-items: center; width: 44px; height: 44px; border: 1px solid var(--color-border); background: transparent; font-size: 22px; } +.theme-icon-dark { display: none; } +[data-theme="dark"] .theme-icon-dark { display: inline; } +[data-theme="dark"] .theme-icon-light { display: none; } +.site-footer { border-top: 1px solid var(--color-border); } +.footer-content { padding: 32px; } +.footer-grid { display: block; } +.footer-section { display: flex; justify-content: space-between; gap: 24px; } +.footer-section h3 { font-size: 16px; letter-spacing: -.02em; } +.footer-section ul { display: flex; gap: 24px; font-size: 13px; } +/* [WEB-DESIGN-LAYOUT] Homepage editorial grid. */ +.home-shell { max-width: var(--max-width); margin: auto; padding: 0 32px; } +.hero { display: grid; grid-template-columns: 1.8fr 1fr; align-items: end; gap: 64px; padding: 64px 0 48px; } +.eyebrow { font: 12px/1.5 var(--font-mono); letter-spacing: .1em; text-transform: uppercase; color: var(--color-muted); } +.hero .eyebrow { display: flex; align-items: center; gap: 10px; margin-bottom: 28px; } +.signal { height: 7px; width: 7px; background: var(--color-primary); } +.hero h1 { font-size: clamp(44px, 5.6vw, 80px); line-height: .96; letter-spacing: -.065em; } +.hero h1 span { color: var(--color-primary); } +.hero-aside { padding-bottom: 6px; } +.hero-aside p { color: var(--color-muted); font-size: 17px; line-height: 1.6; margin-bottom: 24px; } +.text-link { display: inline-flex; gap: 28px; align-items: center; min-height: 44px; font-size: 14px; font-weight: bold; } +.registries { display: flex; flex-wrap: wrap; gap: 0 56px; padding: 20px 0; border-top: 1px solid var(--color-border); } +.registry, .registry ul { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 20px; padding: 0; list-style: none; } +.registry-name { display: inline-flex; align-items: center; gap: 10px; font: 12px/1.5 var(--font-mono); letter-spacing: .1em; text-transform: uppercase; color: var(--color-muted); } +.registry svg { width: 22px; height: 22px; } +.registry a { display: inline-flex; min-height: 44px; align-items: center; gap: 6px; font: 14px var(--font-mono); text-decoration: none; } +.registry a span { color: var(--color-primary); } +.hero-links { display: flex; flex-wrap: wrap; align-items: center; gap: 12px 32px; } +.repo-link { display: inline-flex; align-items: center; gap: 10px; min-height: 44px; padding: 0 18px; background: var(--color-text); color: var(--color-bg); font-size: 14px; font-weight: bold; text-decoration: none; } +.repo-link svg { width: 18px; height: 18px; } +.footer-bottom { display: none; } +.engineering-plate { border-top: 1px solid var(--color-border); } +.engineering-plate img { width: 100%; height: auto; display: block; } +.engineering-plate figcaption { display: flex; justify-content: space-between; gap: 20px; padding: 14px 0; border-bottom: 1px solid var(--color-border); font: 10px/1.5 var(--font-mono); letter-spacing: .08em; text-transform: uppercase; color: var(--color-muted); } +.journal-preview { padding: 56px 0 72px; } +.section-heading { display: flex; justify-content: space-between; align-items: center; gap: 24px; margin-bottom: 32px; } +.journal-row { display: grid; grid-template-columns: 160px 1fr 150px; gap: 32px; border-top: 1px solid var(--color-border); padding: 28px 0; } +.journal-row h3 a { text-decoration: none; } +.journal-row h3 span { color: var(--color-primary); } +.journal-row p { margin-top: 12px; color: var(--color-muted); font-size: 16px; max-width: 54ch; } +.journal-row time { font: 12px/1.7 var(--font-mono); color: var(--color-muted); text-align: right; } +/* Shared techdoc article, list and documentation surfaces. */ +main > .blog-container { max-width: var(--max-width); margin: auto; padding: 56px 32px 72px; } +.blog-header { padding-bottom: 32px; } +.blog-header .eyebrow { margin-bottom: 20px; } +.journal-entry { display: grid; grid-template-columns: 220px minmax(0, 1fr); gap: 32px; padding-block: 32px; border-top: 1px solid var(--color-border); } +.journal-entry h2 { font-size: clamp(28px, 3.5vw, 44px); } +.journal-entry h2 a { text-decoration: none; } +.journal-entry h2 a:hover { text-decoration: underline; } +.journal-entry p:not(.eyebrow) { max-width: 54ch; margin-block: 20px 12px; color: var(--color-muted); } +.blog-subtitle { color: var(--color-muted); margin-top: 24px; } +.blog-nav { display: flex; flex-wrap: wrap; gap: 24px; padding-bottom: 24px; font: 13px var(--font-mono); } +.blog-nav-link { padding: 12px 0; } +.post-list .blog-post { max-width: none; padding: 32px 0; border-top: 1px solid var(--color-border); } +.post-title { font-size: 32px; line-height: 1.2; letter-spacing: -.035em; font-weight: bold; } +.post-meta, .blog-post-meta { font: 12px/1.7 var(--font-mono); color: var(--color-muted); margin: 16px 0; } +.post-excerpt { margin: 16px 0; } +.tag, .tag-link { display: inline-flex; align-items: center; min-height: 44px; padding: 8px 12px; border: 1px solid var(--color-border); font: 12px/1.7 var(--font-mono); } +.post-tags, .tag-cloud { display: flex; flex-wrap: wrap; gap: 8px; } +.category-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 240px), 1fr)); gap: 24px; } +.category-card { display: block; padding: 24px 0; border-block: 1px solid var(--color-border); text-decoration: none; } +.category-card p { margin-top: 12px; color: var(--color-muted); } +main > .blog-post, .article-shell { width: 100%; max-width: 960px; margin-inline: auto; padding: 48px 32px 72px; } +.blog-post-header { max-width: 800px; } +.article-header { margin-bottom: 32px; } +.article-header .eyebrow { margin-bottom: 16px; } +.article-description { color: var(--color-muted); max-width: 56ch; margin-top: 24px; } +.page-illustration { margin: 0 0 32px; background: var(--color-panel); } +.page-illustration img { display: block; width: 100%; height: auto; } +.btn { display: inline-flex; align-items: center; min-height: 44px; padding: 8px 20px; border: 1px solid var(--color-border); } +.docs-layout { grid-template-columns: 180px minmax(0, 1fr); padding: 48px 32px 80px; gap: 48px; } +.sidebar { position: sticky; top: calc(var(--header-height) + 24px); font-size: 14px; } +.sidebar a { display: block; min-height: 44px; padding: 10px 12px; text-decoration: none; border-left: 2px solid var(--color-border); } +.sidebar a.active { color: var(--color-primary); border-color: var(--color-primary); background: var(--color-panel); } +.docs-content { min-width: 0; max-width: none; } +/* [WEB-ACCESS-PROSE] Every long-form surface uses this single prose class. */ +.prose { width: 100%; max-width: var(--content-width); margin-inline: auto; overflow-wrap: anywhere; } +.prose > * + * { margin-top: 24px; } +.prose > :first-child { margin-top: 0; } +.prose :is(h1, h2, h3, h4) { scroll-margin-top: calc(var(--header-height) + 24px); } +.prose :is(h2, h3, h4) { margin-top: 48px; margin-bottom: 16px; } +.prose h2 { font-size: clamp(28px, 3vw, 36px); } +.prose h3 { font-size: 25px; } +.prose h4 { font-size: 20px; line-height: 1.3; } +.prose .header-anchor { text-decoration: none; } +.prose .header-anchor:hover { text-decoration: underline; text-decoration-thickness: 1px; } +.prose :is(ul, ol) { padding-left: 1.5em; } +.prose li + li { margin-top: 8px; } +.prose li > :is(ul, ol) { margin-block: 12px; } +.prose li::marker { color: var(--color-primary); } +.prose blockquote { margin-inline: 0; border-left: 3px solid var(--color-primary); padding: 12px 24px; font-size: clamp(20px, 2.5vw, 24px); letter-spacing: -.02em; } +.prose blockquote p + p { margin-top: 16px; } +.prose :is(code, pre) { font-family: var(--font-mono); background: var(--color-panel); } +.prose code { padding: 3px 6px; font-size: .85em; } +.prose pre { max-width: 100%; padding: 24px; overflow-x: auto; border: 1px solid var(--color-border); line-height: 1.6; } +.prose pre code { padding: 0; white-space: pre; overflow-wrap: normal; } +.prose .table-scroll { max-width: 100%; overflow-x: auto; } +.prose table { width: 100%; border-collapse: collapse; font-size: 16px; text-align: left; } +.prose :is(th, td) { padding: 16px; vertical-align: top; border-bottom: 1px solid var(--color-border); } +.prose thead { background: var(--color-panel); } +.prose img { display: block; max-width: 100%; height: auto; } +/* [WEB-EXAMPLES] Example videos and screenshot grid. */ +.home-proof { max-width: none; padding: 48px 0; border-top: 1px solid var(--color-border); } +.prose .example-video { margin: 32px 0; } +.prose video { display: block; width: 100%; height: auto; background: var(--color-panel); border: 1px solid var(--color-border); } +.prose .example-shots { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 24px; margin: 32px 0; } +.prose .example-shots img { border: 1px solid var(--color-border); } +.prose .example-shots figure:only-child { grid-column: 1 / -1; } +@media (max-width: 768px) { .prose .example-shots { grid-template-columns: 1fr; } } +.prose figcaption { margin-top: 12px; color: var(--color-muted); font: 12px/1.6 var(--font-mono); } +.prose .example-project { display: block; margin-bottom: 4px; color: var(--color-text); font: 15px/1.5 Arial, Helvetica, sans-serif; text-decoration: none; } +.prose .example-project strong { color: var(--color-primary); } +.prose hr { margin-block: 40px; border: 0; border-top: 1px solid var(--color-border); } +.prose details { padding: 16px 20px; border-block: 1px solid var(--color-border); } +.prose summary { cursor: pointer; font-weight: bold; min-height: 44px; padding-block: 8px; } +.prose details > p { margin-block: 16px; } +.token.comment { color: var(--color-muted); } +.token.keyword, .token.function, .token.string { color: var(--color-primary); } +.skip-link { position: fixed; top: -100px; left: 16px; z-index: 200; padding: 12px 20px; background: var(--color-text); color: var(--color-bg); } +.skip-link:focus { top: 12px; } +/* [WEB-ACCESS] Mobile uses the plugin's real menu interaction. */ +@media (max-width: 768px) { + :root { --header-height: 85px; } + .nav, .footer-content { padding: 20px; } + .nav-actions { margin-left: auto; } + .nav-links { margin: 0; background: var(--color-bg); border-bottom: 1px solid var(--color-border); gap: 8px; padding: 20px; max-height: calc(100dvh - var(--header-height)); overflow-y: auto; } + .mobile-menu-toggle { min-width: 44px; min-height: 44px; align-items: center; justify-content: center; } + .home-shell { padding: 0 20px; } + .hero { grid-template-columns: 1fr; gap: 28px; padding: 40px 0 32px; } + .hero-aside { max-width: 42ch; } + .hero .eyebrow { font-size: 10px; margin-bottom: 24px; } + .hero-aside p { margin-bottom: 12px; } + .engineering-plate figcaption { font-size: 8px; } + .engineering-plate figcaption span:last-child { display: none; } + .journal-preview { padding: 40px 0; } + .section-heading { align-items: start; gap: 16px; } + .section-heading .text-link { flex-shrink: 0; gap: 10px; } + .journal-row { grid-template-columns: 1fr; gap: 16px; } + .journal-entry { grid-template-columns: minmax(0, 1fr); gap: 16px; } + .journal-row time { text-align: left; } + .footer-section, .footer-section ul { flex-wrap: wrap; } + main > .blog-container, main > .blog-post, .article-shell { padding: 32px 20px 48px; } + .docs-layout { grid-template-columns: minmax(0, 1fr); padding: 24px 20px 48px; gap: 32px; } + .docs-layout .sidebar { position: static; width: auto; height: auto; transform: none; transition: none; padding: 0; border: 0; z-index: auto; } + .docs-nav > ul { display: flex; flex-wrap: wrap; gap: 8px; } + .sidebar a { border: 1px solid var(--color-border); padding: 8px 12px; } + .article-header h1, .blog-post-header h1, .blog-header h1 { font-size: clamp(36px, 8vw, 56px); overflow-wrap: anywhere; } + .prose { font-size: 17px; } + .prose :is(h2, h3, h4) { margin-top: 36px; } + .prose :is(th, td) { padding: 12px; min-width: 120px; } + .prose pre { padding: 16px; } + .prose blockquote { padding: 8px 16px; } +} diff --git a/website/_site/assets/images/apple-touch-icon.png b/website/_site/assets/images/apple-touch-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..5df47222a646b5758bee3bf336a4547fd4eb64c4 GIT binary patch literal 17511 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 D+jNi} literal 0 HcmV?d00001 diff --git a/website/_site/assets/images/engine.svg b/website/_site/assets/images/engine.svg new file mode 100644 index 0000000..135e3e4 --- /dev/null +++ b/website/_site/assets/images/engine.svg @@ -0,0 +1,32 @@ + + One engine, two surfaces + An architectural drawing of an orange core connected to two dark terminals. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/website/_site/assets/images/examples/osprey-flamegraph.webp b/website/_site/assets/images/examples/osprey-flamegraph.webp new file mode 100644 index 0000000000000000000000000000000000000000..9a5d9f79f21024ff0b5b6f976832134a7a9dd7f8 GIT binary patch literal 55720 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

wQd+e<%S-aRwSVDZ?X5l)1lA6w0`Eh-w8MwxiQ6 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 QTZiD1bA7q(&DZ6C0InjDl>h($ literal 0 HcmV?d00001 diff --git a/website/_site/assets/images/examples/osprey-heatmap.webp b/website/_site/assets/images/examples/osprey-heatmap.webp new file mode 100644 index 0000000000000000000000000000000000000000..826cec91deba26431091060568d1dd6cf7b1e401 GIT binary patch literal 50656 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 literal 0 HcmV?d00001 diff --git a/website/_site/assets/images/favicon.ico b/website/_site/assets/images/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..4ed0ce8091511a6bc2136a492607154994acca37 GIT binary patch literal 15086 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 ReBwK@J~@_Fj|cUA{{MQv#{mEU literal 0 HcmV?d00001 diff --git a/website/_site/assets/images/logo.png b/website/_site/assets/images/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..05bce1e9f603ab10b1b2ab7c06adde55f4e58a2c GIT binary patch literal 109605 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℘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%0A$rbd0&q82hL~=YIY`}6#RcD2w$_WJ! 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 SZ1)$qw + lspkit — The foundation for any language's tooling. + The lspkit wordmark and headline beside an engineering plate: one vermilion engine routes to two terminal surfaces, LSP and MCP. + + + + + + + + + + + lspkit + THE LANGUAGE SERVER TOOLKIT + The foundation + for any language's + tooling. + RUST · LSP · MCP · PROFILER + FIG. 01 — ONE ENGINE, TWO SURFACES + + + + + + + + + Your engine + + LSP + + MCP + + PROFILE + diff --git a/website/_site/blog/categories/field-notes/index.html b/website/_site/blog/categories/field-notes/index.html new file mode 100644 index 0000000..6d97f70 --- /dev/null +++ b/website/_site/blog/categories/field-notes/index.html @@ -0,0 +1,254 @@ + + + + + + + + + Field-notes + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ +
+
+
+

Field-notes

+

← All categories

+
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/categories/index.html b/website/_site/blog/categories/index.html new file mode 100644 index 0000000..f74a2cc --- /dev/null +++ b/website/_site/blog/categories/index.html @@ -0,0 +1,229 @@ + + + + + + + + + Categories + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+

Categories

+

Browse blog posts by category.

+
+ + + + +
+ +
+ + + + + + + + + diff --git a/website/_site/blog/index.html b/website/_site/blog/index.html new file mode 100644 index 0000000..4aaf325 --- /dev/null +++ b/website/_site/blog/index.html @@ -0,0 +1,236 @@ + + + + + + + + + Journal — lspkit + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+

The lspkit journal

+

Notes from the workbench.

+

Ideas, decisions and working notes on building better developer tools.

+
+
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/one-engine/index.html b/website/_site/blog/one-engine/index.html new file mode 100644 index 0000000..c6be5eb --- /dev/null +++ b/website/_site/blog/one-engine/index.html @@ -0,0 +1,321 @@ + + + + + + + + + Build an MCP server and a language server from one Rust engine. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + +
+
+
+ +

Build an MCP server and a language server from one Rust engine.

+ + + +
+ +
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+

Your VS Code extension talks to a language server over the Language Server Protocol (LSP). AI coding agents such as Claude Code, Cursor and Codex talk to tools over the Model Context Protocol (MCP). If you build developer tools, you now need both, and they should give the same answers.

+

What is an MCP server?

+

An MCP server exposes tools and data to an AI agent over a small JSON-RPC protocol. Where a language server answers "what's the type at this cursor?" for an editor, an MCP server answers "find every caller of this function" for an agent. Both need the same thing underneath: a live, accurate model of the code.

+

The trap: two pipelines

+

The obvious build is a language server with its own caches, then an MCP server bolted on with another set. Now two pipelines parse the same files, watch the same folders and drift apart. The agent sees stale results the editor has already fixed.

+

One engine, two surfaces

+

lspkit puts analysis behind one Rust trait, EngineApi. The lspkit-server crate serves it over LSP to VS Code; its mcp feature serves the same engine over MCP to Claude Code, Cursor or Codex.

+
cargo add lspkit lspkit-server --features lspkit-server/mcp
+

Every report carries a generation number, so the editor and the agent can both tell which state of the workspace produced an answer. Cancellation and progress live at the same boundary, so a slow query from the agent never blocks the editor.

+

Find the memory leak before your users do

+

Long-running language servers leak. lspkit ships lsp-profiler, a CPU and memory profiler that runs inside VS Code: hot lines painted in your source, a flame graph beside it, and a live heap timeline that ranks memory leak suspects. SharpLsp uses it for C# and F#; Osprey uses it for a native functional language. Watch both on the examples page.

+
SharpLsp · C# and F# language server for VS Code ↗Finding and fixing a memory leak in a running C# app. Watch the walkthrough ↗
+ +

Start building

+ +
+ + +
+ + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/tags/index.html b/website/_site/blog/tags/index.html new file mode 100644 index 0000000..43dacc3 --- /dev/null +++ b/website/_site/blog/tags/index.html @@ -0,0 +1,244 @@ + + + + + + + + + Tags + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ + + + + + + + + diff --git a/website/_site/blog/tags/language-server-protocol/index.html b/website/_site/blog/tags/language-server-protocol/index.html new file mode 100644 index 0000000..0c4e054 --- /dev/null +++ b/website/_site/blog/tags/language-server-protocol/index.html @@ -0,0 +1,254 @@ + + + + + + + + + Posts tagged 'language-server-protocol' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+

Posts tagged "language-server-protocol"

+

← All tags

+
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/tags/mcp-server/index.html b/website/_site/blog/tags/mcp-server/index.html new file mode 100644 index 0000000..eb04efd --- /dev/null +++ b/website/_site/blog/tags/mcp-server/index.html @@ -0,0 +1,254 @@ + + + + + + + + + Posts tagged 'mcp-server' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+

Posts tagged "mcp-server"

+

← All tags

+
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/tags/rust/index.html b/website/_site/blog/tags/rust/index.html new file mode 100644 index 0000000..d41bd56 --- /dev/null +++ b/website/_site/blog/tags/rust/index.html @@ -0,0 +1,254 @@ + + + + + + + + + Posts tagged 'rust' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+

Posts tagged "rust"

+

← All tags

+
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/blog/tags/vscode-extension/index.html b/website/_site/blog/tags/vscode-extension/index.html new file mode 100644 index 0000000..1729cb6 --- /dev/null +++ b/website/_site/blog/tags/vscode-extension/index.html @@ -0,0 +1,254 @@ + + + + + + + + + Posts tagged 'vscode-extension' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+

Posts tagged "vscode-extension"

+

← All tags

+
+ +
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/docs/crates/index.html b/website/_site/docs/crates/index.html new file mode 100644 index 0000000..bf818a8 --- /dev/null +++ b/website/_site/docs/crates/index.html @@ -0,0 +1,392 @@ + + + + + + + + + Crates. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + +
+
+

Documentation

+

Crates.

+

What each published crate and package provides.

+
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CrateWhat it gives you
lspkitEngineApi and its types, plus the config, vfs and sidecar modules.
lspkit-serverJSON-RPC LSP server scaffolding on lsp-types: capabilities, dispatch, URIs, diagnostics, progress, cancellation and live file watching.
lsp-profilerLanguage-neutral CPU and memory profiler for language servers.
lsp-profiler-dotnetThe profiler's .NET runtime, using EventPipe.
+
SharpLsp sidebar with the Processes view listing a running .NET process with Profile CPU and Track Memory actions
SharpLsp · C# and F# language server for VS Code ↗Processes view: profile any running process.
SharpLsp Profiler results panel with summary cards, an embedded flame graph and the hot functions table
SharpLsp · C# and F# language server for VS Code ↗Results panel, flame graph and hot functions.
+

Features

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CrateFeatureAdds
lspkittreesitterTree-sitter parsing helpers.
lspkittracing-setupA ready-made tracing subscriber.
lspkit-servermcpThe MCP adapter over the same engine.
lspkit-serverpullPull-based incremental analysis with salsa.
+

Editor package

+

@nimblesite/lsp-profiler-ui is the VS Code UI for the profiler: processes, CPU heat map, flame graph, memory dashboard and retention graph. It also carries Debug Adapter Protocol glue for extension tests.

+
npm install @nimblesite/lsp-profiler-ui
+ +
+ + + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/docs/examples/index.html b/website/_site/docs/examples/index.html new file mode 100644 index 0000000..99ae53f --- /dev/null +++ b/website/_site/docs/examples/index.html @@ -0,0 +1,343 @@ + + + + + + + + + Built with lspkit. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + +
+
+

Documentation

+

Built with lspkit.

+

SharpLsp and Osprey ship the lspkit profiler in VS Code today.

+
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+

Two language servers run on lspkit today. Both mount the same lsp-profiler engine and the same @nimblesite/lsp-profiler-ui panels; only the runtime crate differs.

+

SharpLsp: C# and F#

+

SharpLsp is a C# and F# language server for VS Code. Its profiler attaches to any running .NET process through lsp-profiler-dotnet, paints hot lines in your code, and ranks leak suspects while the app runs.

+
SharpLsp · C# and F# language server for VS Code ↗SharpLsp profiling a real .NET app in VS Code. Watch the walkthrough ↗
+ +
SharpLsp · C# and F# language server for VS Code ↗The same profiler on F#: pipeline stages keep their compiler names. Watch the walkthrough ↗
+

Read the SharpLsp profiler guide ↗

+

Osprey: a native functional language

+

Osprey is a functional language with algebraic effects that compiles to native code. Its VS Code extension uses the same profiler to run and profile the open file, attach to a running program, and check for leaks.

+
Osprey · native functional language with a VS Code extension ↗Osprey's VS Code extension running the lspkit profiler. Watch the walkthrough ↗
+ +

Watch the Osprey profiler tutorial ↗

+

Add your language

+

A new language needs only a runtime crate that samples its processes. See Profiler for how the pieces fit.

+
+ + + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/docs/getting-started/index.html b/website/_site/docs/getting-started/index.html new file mode 100644 index 0000000..53b44c2 --- /dev/null +++ b/website/_site/docs/getting-started/index.html @@ -0,0 +1,364 @@ + + + + + + + + + Getting started. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + +
+
+

Documentation

+

Getting started.

+

Add lspkit to a language server and implement the engine.

+
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+

This is what you are building toward: your language server, profiled inside VS Code.

+
Osprey · native functional language with a VS Code extension ↗Osprey's VS Code extension running the lspkit profiler. Watch the walkthrough ↗
+

Add the crates

+
cargo add lspkit lspkit-server
+

Turn on the features you need:

+
cargo add lspkit --features treesitter
+cargo add lspkit-server --features mcp
+

Implement the engine

+

Your analysis implements EngineApi. It defines its own report, query and error types, and four operations:

+
#[async_trait]
+pub trait EngineApi: Send + Sync + 'static {
+    type Report: Send + Sync + 'static;
+    type Query: Send + Sync;
+    type Error: StdError + Send + Sync + 'static;
+
+    fn generation(&self) -> Generation;
+    async fn report(&self, query: Self::Query, cancel: CancellationToken)
+        -> Result<Snapshot<Self::Report>, Self::Error>;
+    async fn rescan(&self, scope: RescanScope, progress: Progress)
+        -> Result<RescanTicket, Self::Error>;
+    fn subscribe(&self) -> GenerationEventStream;
+    async fn shutdown(&self) -> Result<(), Self::Error>;
+}
+
    +
  • generation increases on every successful rescan.
  • +
  • report answers a query from a snapshot and stops promptly when cancelled.
  • +
  • rescan refreshes the analysis and may coalesce concurrent requests.
  • +
  • subscribe streams generation changes to listeners.
  • +
  • shutdown drains in-flight work; every later call returns an error.
  • +
+

Serve it

+

Hand one engine instance to the lspkit-server scaffolding for the editor and, with the mcp feature, to the MCP adapter for agents. Both read the same snapshots.

+ +

Learn more

+

The full behavioural contract is in the spec, and the API reference is on docs.rs.

+
+ + + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/docs/index.html b/website/_site/docs/index.html new file mode 100644 index 0000000..258ab36 --- /dev/null +++ b/website/_site/docs/index.html @@ -0,0 +1,346 @@ + + + + + + + + + A small foundation. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + +
+
+

Documentation

+

A small foundation.

+

One engine behind your language server and MCP server, with a profiler built into VS Code.

+
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+

lspkit is a set of Rust crates for building language servers. Your analysis runs once, in one engine, and both an LSP server and an MCP server read from it.

+
SharpLsp · C# and F# language server for VS Code ↗SharpLsp profiling a real .NET app in VS Code. Watch the walkthrough ↗
+

One engine

+

EngineApi is the boundary between your analysis and the protocols. Every report carries a generation number, so a client always knows which state of the workspace produced an answer.

+

Two surfaces

+

The LSP server and the MCP adapter consume the same engine. Protocol handling stays at the edges; analysis lives in one place.

+

Shared plumbing

+

File tracking, configuration, sidecar processes, tree-sitter parsing, transport and profiling are ready-made. Use the parts that fit your server.

+ +

Next steps

+ +
+ + + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/docs/profiler/index.html b/website/_site/docs/profiler/index.html new file mode 100644 index 0000000..fcdad2b --- /dev/null +++ b/website/_site/docs/profiler/index.html @@ -0,0 +1,350 @@ + + + + + + + + + Profiler. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + +
+ + +
+
+

Documentation

+

Profiler.

+

One CPU and memory profiler for every language server.

+
+ +
+ An orange shared engine connects to two terminal surfaces through circuit paths. +
+ +
+

lsp-profiler profiles a running language server without leaving the editor. A language plugs in a runtime crate; sessions, reports and the protocol are shared.

+
SharpLsp · C# and F# language server for VS Code ↗Unedited, in real time: Profile CPU on a running process, then the results open. Watch the walkthrough ↗
+

What it measures

+
    +
  • CPU: sampling sessions, hotspots and flame graphs, exported as speedscope or V8 profiles.
  • +
  • Memory: heap snapshots, retention paths and leak scoring.
  • +
+ + +
SharpLsp · C# and F# language server for VS Code ↗Memory tracking, sped up three times: the heap timeline climbs and leak suspects appear. Watch the walkthrough ↗
+

How it fits together

+
    +
  1. Your server mounts lsp-profiler and a runtime crate, such as lsp-profiler-dotnet for .NET.
  2. +
  3. The editor talks to it over one JSON-RPC protocol.
  4. +
  5. @nimblesite/lsp-profiler-ui renders the results in VS Code.
  6. +
+ +

Add it

+
cargo add lsp-profiler
+cargo add lsp-profiler-dotnet   # for .NET language servers
+

See it running in SharpLsp and Osprey. The full design is in the profiler spec.

+
+ + + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/feed.xml b/website/_site/feed.xml new file mode 100644 index 0000000..ab36378 --- /dev/null +++ b/website/_site/feed.xml @@ -0,0 +1,18 @@ + + + lspkit — The foundation for any language's tooling. + lspkit is the language server toolkit: write your language analysis once in Rust, serve it over LSP and as an MCP server, and profile it with a CPU and memory profiler built into VS Code. + + + 2026-10-31T00:00:00.000Z + http://localhost:8080/ + + + Build an MCP server and a language server from one Rust engine. + + http://localhost:8080/blog/one-engine/ + 2026-10-31T00:00:00.000Z + http://localhost:8080/%3C!--%20[WEB-CONTENT]%20[WEB-SEO-KEYWORDS]%20Keywords%20from%20Google%20Trends,%2012%20months%20to%202026-10:%20%22mcp%20server%22,%20%22what%20is%20mcp%20server%22,%20%22claude%20code%22,%20%22cursor%22,%20%22codex%22,%20%22language%20server%20protocol%22,%20%22rust%20language%20server%22,%20%22vscode%20extension%22,%20%22memory%20leak%22.%20--%3E%3Cp%3EYour%20VS%20Code%20extension%20talks%20to%20a%20%3Cstrong%3Elanguage%20server%3C/strong%3E%20over%20the%20%3Cstrong%3ELanguage%20Server%20Protocol%3C/strong%3E%20(LSP).%20AI%20coding%20agents%20such%20as%20%3Cstrong%3EClaude%20Code%3C/strong%3E,%20%3Cstrong%3ECursor%3C/strong%3E%20and%20%3Cstrong%3ECodex%3C/strong%3E%20talk%20to%20tools%20over%20the%20%3Cstrong%3EModel%20Context%20Protocol%3C/strong%3E%20(MCP).%20If%20you%20build%20developer%20tools,%20you%20now%20need%20both,%20and%20they%20should%20give%20the%20same%20answers.%3C/p%3E%3Ch2%20id=%22what-is-an-mcp-server%22%20tabindex=%22-1%22%3E%3Ca%20class=%22header-anchor%22%20href=%22#what-is-an-mcp-server%22%3EWhat%20is%20an%20MCP%20server?%3C/a%3E%3C/h2%3E%3Cp%3EAn%20MCP%20server%20exposes%20tools%20and%20data%20to%20an%20AI%20agent%20over%20a%20small%20JSON-RPC%20protocol.%20Where%20a%20language%20server%20answers%20&quot;what's%20the%20type%20at%20this%20cursor?&quot;%20for%20an%20editor,%20an%20MCP%20server%20answers%20&quot;find%20every%20caller%20of%20this%20function&quot;%20for%20an%20agent.%20Both%20need%20the%20same%20thing%20underneath:%20a%20live,%20accurate%20model%20of%20the%20code.%3C/p%3E%3Ch2%20id=%22the-trap-two-pipelines%22%20tabindex=%22-1%22%3E%3Ca%20class=%22header-anchor%22%20href=%22#the-trap-two-pipelines%22%3EThe%20trap:%20two%20pipelines%3C/a%3E%3C/h2%3E%3Cp%3EThe%20obvious%20build%20is%20a%20language%20server%20with%20its%20own%20caches,%20then%20an%20MCP%20server%20bolted%20on%20with%20another%20set.%20Now%20two%20pipelines%20parse%20the%20same%20files,%20watch%20the%20same%20folders%20and%20drift%20apart.%20The%20agent%20sees%20stale%20results%20the%20editor%20has%20already%20fixed.%3C/p%3E%3Ch2%20id=%22one-engine-two-surfaces%22%20tabindex=%22-1%22%3E%3Ca%20class=%22header-anchor%22%20href=%22#one-engine-two-surfaces%22%3EOne%20engine,%20two%20surfaces%3C/a%3E%3C/h2%3E%3Cp%3Elspkit%20puts%20analysis%20behind%20one%20Rust%20trait,%20%3Ccode%3EEngineApi%3C/code%3E.%20The%20%3Ccode%3Elspkit-server%3C/code%3E%20crate%20serves%20it%20over%20LSP%20to%20VS%20Code;%20its%20%3Ccode%3Emcp%3C/code%3E%20feature%20serves%20the%20same%20engine%20over%20MCP%20to%20Claude%20Code,%20Cursor%20or%20Codex.%3C/p%3E%3Cpre%20class=%22language-sh%22%3E%3Ccode%20class=%22language-sh%22%3E%3Cspan%20class=%22token%20function%22%3Ecargo%3C/span%3E%20%3Cspan%20class=%22token%20function%22%3Eadd%3C/span%3E%20lspkit%20lspkit-server%20%3Cspan%20class=%22token%20parameter%20variable%22%3E--features%3C/span%3E%20lspkit-server/mcp%3C/code%3E%3C/pre%3E%3Cp%3EEvery%20report%20carries%20a%20%3Cstrong%3Egeneration%3C/strong%3E%20number,%20so%20the%20editor%20and%20the%20agent%20can%20both%20tell%20which%20state%20of%20the%20workspace%20produced%20an%20answer.%20Cancellation%20and%20progress%20live%20at%20the%20same%20boundary,%20so%20a%20slow%20query%20from%20the%20agent%20never%20blocks%20the%20editor.%3C/p%3E%3Ch2%20id=%22find-the-memory-leak-before-your-users-do%22%20tabindex=%22-1%22%3E%3Ca%20class=%22header-anchor%22%20href=%22#find-the-memory-leak-before-your-users-do%22%3EFind%20the%20memory%20leak%20before%20your%20users%20do%3C/a%3E%3C/h2%3E%3Cp%3ELong-running%20language%20servers%20leak.%20lspkit%20ships%20%3Ccode%3Elsp-profiler%3C/code%3E,%20a%20CPU%20and%20memory%20profiler%20that%20runs%20inside%20VS%20Code:%20hot%20lines%20painted%20in%20your%20source,%20a%20flame%20graph%20beside%20it,%20and%20a%20live%20heap%20timeline%20that%20ranks%20%3Cstrong%3Ememory%20leak%3C/strong%3E%20suspects.%20%3Ca%20href=%22https://sharplsp.dev/docs/profiler/%22%3ESharpLsp%3C/a%3E%20uses%20it%20for%20C#%20and%20F#;%20%3Ca%20href=%22https://www.ospreylang.dev/docs/tutorials/profiler/%22%3EOsprey%3C/a%3E%20uses%20it%20for%20a%20native%20functional%20language.%20%3Ca%20href=%22/docs/examples/%22%3EWatch%20both%20on%20the%20examples%20page%3C/a%3E.%3C/p%3E%3Cfigure%20class=%22example-video%22%3E%3Cvideo%20controls%20preload=%22metadata%22%20playsinline%20width=%221920%22%20height=%221200%22%20poster=%22https://sharplsp.dev/assets/videos/profiler-fix-memory-leak-poster.webp%22%20aria-label=%22Fixing%20a%20C#%20memory%20leak%20in%20VS%20Code%20with%20the%20SharpLsp%20memory%20profiler,%20from%20leak%20suspects%20to%20the%20retaining%20path%22%3E%3Csource%20src=%22https://sharplsp.dev/assets/videos/profiler-fix-memory-leak.webm%22%20type=%22video/webm%22%3E%3Csource%20src=%22https://sharplsp.dev/assets/videos/profiler-fix-memory-leak.mp4%22%20type=%22video/mp4%22%3E%3Ctrack%20kind=%22captions%22%20src=%22https://sharplsp.dev/assets/videos/profiler-fix-memory-leak.en.vtt%22%20srclang=%22en%22%20label=%22English%22%3E%3C/video%3E%3Cfigcaption%3E%3Ca%20class=%22example-project%22%20href=%22https://sharplsp.dev%22%3E%3Cstrong%3ESharpLsp%3C/strong%3E%20%C2%B7%20C#%20and%20F#%20language%20server%20for%20VS%20Code%20%E2%86%97%3C/a%3EFinding%20and%20fixing%20a%20memory%20leak%20in%20a%20running%20C#%20app.%20%3Ca%20href=%22https://sharplsp.dev/docs/memory-leaks/%22%3EWatch%20the%20walkthrough%20%E2%86%97%3C/a%3E%3C/figcaption%3E%3C/figure%3E%3Cdiv%20class=%22example-shots%22%3E%3Cfigure%3E%3Cimg%20src=%22https://sharplsp.dev/assets/screenshots/profiler/profiler-leaks.webp%22%20width=%222400%22%20height=%221500%22%20loading=%22lazy%22%20alt=%22Suspected%20leaks%20ranked%20HIGH%20with%20growth%20in%20megabytes%20and%20object%20counts,%20and%20an%20inline%20leak%20marker%20on%20the%20CustomerSession%20declaration%22%3E%3Cfigcaption%3E%3Ca%20class=%22example-project%22%20href=%22https://sharplsp.dev%22%3E%3Cstrong%3ESharpLsp%3C/strong%3E%20%C2%B7%20C#%20and%20F#%20language%20server%20for%20VS%20Code%20%E2%86%97%3C/a%3ERanked%20leak%20suspects,%20marked%20in%20the%20source.%3C/figcaption%3E%3C/figure%3E%3Cfigure%3E%3Cimg%20src=%22/assets/images/examples/osprey-heatmap.webp%22%20width=%221276%22%20height=%22714%22%20loading=%22lazy%22%20alt=%22busy.osp%20in%20VS%20Code%20with%20inline%20heat%20bars:%20collatz%2076.4%20percent,%20longest%2073.0%20percent,%20fib%2022.5%20percent%22%3E%3Cfigcaption%3E%3Ca%20class=%22example-project%22%20href=%22https://www.ospreylang.dev%22%3E%3Cstrong%3EOsprey%3C/strong%3E%20%C2%B7%20native%20functional%20language%20with%20a%20VS%20Code%20extension%20%E2%86%97%3C/a%3EHeat%20on%20Osprey%20source.%3C/figcaption%3E%3C/figure%3E%3C/div%3E%3Ch2%20id=%22start-building%22%20tabindex=%22-1%22%3E%3Ca%20class=%22header-anchor%22%20href=%22#start-building%22%3EStart%20building%3C/a%3E%3C/h2%3E%3Cul%3E%3Cli%3E%3Ca%20href=%22/docs/getting-started/%22%3EGetting%20started%3C/a%3E:%20add%20the%20crates%20and%20implement%20%3Ccode%3EEngineApi%3C/code%3E.%3C/li%3E%3Cli%3E%3Ca%20href=%22/docs/crates/%22%3ECrates%3C/a%3E:%20what%20each%20crate%20and%20feature%20gives%20you.%3C/li%3E%3Cli%3E%3Ca%20href=%22https://github.com/Nimblesite/lspkit%22%3ESource%20on%20GitHub%20%E2%86%97%3C/a%3E%3C/li%3E%3C/ul%3E + How to give Claude Code, Cursor and Codex the same live code intelligence as your VS Code extension, with one Rust engine behind an MCP server and a language server. + + diff --git a/website/_site/index.html b/website/_site/index.html new file mode 100644 index 0000000..79d7b1c --- /dev/null +++ b/website/_site/index.html @@ -0,0 +1,259 @@ + + + + + + + + + lspkit — The foundation for any language's tooling. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+
+

The language server toolkit

+

The foundation for
any language's tooling.

+
+
+

Write your language analysis once, as one Rust trait. lspkit serves it to your VS Code extension over the Language Server Protocol and to Claude Code, Cursor and Codex as an MCP server. Find the hot path and the memory leak with a profiler built into VS Code.

+ +
+
+ +
+ + + + + +
+
+

See it running.

+

SharpLsp and Osprey ship the lspkit profiler in VS Code today: hot lines in the source, a flame graph beside it, and ranked memory leak suspects. See both examples.

+
SharpLsp · C# and F# language server for VS Code ↗SharpLsp profiling a real .NET app in VS Code. Watch the walkthrough ↗
+ +
+
+ An orange engine connects through precise circuit paths to two dark terminal surfaces, representing LSP and MCP. +
FIG. A — One engine, two surfaces.LSP / MCP / PROFILER
+
+
+

From the workbench.

All notes
+ + + +
+
+ +
+ + + + + + + + + diff --git a/website/_site/llms.txt b/website/_site/llms.txt new file mode 100644 index 0000000..9afa2d4 --- /dev/null +++ b/website/_site/llms.txt @@ -0,0 +1,27 @@ +# lspkit — The foundation for any language's tooling. + +> lspkit is the language server toolkit: write your language analysis once in Rust, serve it over LSP and as an MCP server, and profile it with a CPU and memory profiler built into VS Code. + +## Documentation + +- [Crates.](http://localhost:8080/docs/crates/) + +- [Built with lspkit.](http://localhost:8080/docs/examples/) + +- [Getting started.](http://localhost:8080/docs/getting-started/) + +- [A small foundation.](http://localhost:8080/docs/) + +- [Profiler.](http://localhost:8080/docs/profiler/) + + +## Blog Posts + +- [Build an MCP server and a language server from one Rust engine.](http://localhost:8080/blog/one-engine/) + + +## Navigation +- Home: http://localhost:8080/ +- Documentation: http://localhost:8080/docs/ +- Blog: http://localhost:8080/blog/ +- API Reference: http://localhost:8080/api/ diff --git a/website/_site/robots.txt b/website/_site/robots.txt new file mode 100644 index 0000000..a1655c0 --- /dev/null +++ b/website/_site/robots.txt @@ -0,0 +1,60 @@ +# lspkit — The foundation for any language's tooling. +# http://localhost:8080 + +# Allow all crawlers +User-agent: * +Allow: / +Disallow: /assets/ +Disallow: /search? + +# AI Crawlers - Welcome! +User-agent: GPTBot +Allow: / + +User-agent: ChatGPT-User +Allow: / + +User-agent: Google-Extended +Allow: / + +User-agent: Googlebot +Allow: / + +User-agent: Bingbot +Allow: / + +User-agent: ClaudeBot +Allow: / + +User-agent: Anthropic-AI +Allow: / + +User-agent: PerplexityBot +Allow: / + +User-agent: Cohere-ai +Allow: / + +User-agent: Meta-ExternalAgent +Allow: / + +User-agent: Meta-ExternalFetcher +Allow: / + +User-agent: Bytespider +Allow: / + +User-agent: CCBot +Allow: / + +User-agent: Applebot +Allow: / + +User-agent: Amazonbot +Allow: / + +# Sitemaps +Sitemap: http://localhost:8080/sitemap.xml + +# AI Context File +# See https://llmstxt.org for the llms.txt specification diff --git a/website/_site/sitemap.xml b/website/_site/sitemap.xml new file mode 100644 index 0000000..77a5d1e --- /dev/null +++ b/website/_site/sitemap.xml @@ -0,0 +1,75 @@ + + + + http://localhost:8080/blog/one-engine/ + 2026-10-31T00:00:00.000Z + 0.7 + monthly + + + http://localhost:8080/docs/crates/ + 2026-11-16T10:00:55.240Z + 0.8 + monthly + + + http://localhost:8080/docs/examples/ + 2026-11-16T10:00:55.240Z + 0.8 + monthly + + + http://localhost:8080/docs/getting-started/ + 2026-11-16T10:00:55.240Z + 0.8 + monthly + + + http://localhost:8080/docs/ + 2026-11-16T10:00:55.240Z + 0.8 + monthly + + + http://localhost:8080/docs/profiler/ + 2026-11-16T10:00:55.241Z + 0.8 + monthly + + + http://localhost:8080/ + 2026-11-16T10:00:55.241Z + 1.0 + weekly + + + http://localhost:8080/blog/categories/field-notes/ + 2026-11-16T11:01:04.305Z + 0.7 + monthly + + + http://localhost:8080/blog/categories/ + 2026-11-16T11:01:04.305Z + 0.7 + monthly + + + http://localhost:8080/blog/ + 2026-11-16T11:01:04.305Z + 0.7 + monthly + + + http://localhost:8080/blog/tags/language-server-protocol/ + 2026-11-16T11:01:04.305Z + 0.7 + monthly + + + http://localhost:8080/blog/tags/ + 2026-11-16T11:01:04.305Z + 0.7 + monthly + + diff --git a/website/_site/techdoc/css/layout.css b/website/_site/techdoc/css/layout.css new file mode 100644 index 0000000..06ccd91 --- /dev/null +++ b/website/_site/techdoc/css/layout.css @@ -0,0 +1,243 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ HOW TO CUSTOMIZE LAYOUT: ║ + * ║ 1. Override CSS vars: --max-width, --sidebar-width, --content-width ║ + * ║ 2. Add rules with higher specificity in YOUR styles.css ║ + * ║ 3. Use !important sparingly if truly needed ║ + * ║ ║ + * ║ Example in your styles.css: ║ + * ║ :root { --max-width: 1400px; --sidebar-width: 280px; } ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * techdoc layout.css + * Structural layout only - NO colors, NO decorative styles + * Sites must provide all visual styling + */ + +/* Site structure */ +body { + margin: 0; + min-height: 100vh; + display: flex; + flex-direction: column; +} + +main { + flex: 1; +} + +/* Theme-owned resets — scoped so reset.css can stay global-free and never + clobber the consuming site's content lists, buttons, or spacing. */ +.nav-links, +.sidebar ul, +.footer-section ul { + list-style: none; + margin: 0; + padding: 0; +} + +.theme-toggle, +.language-btn, +.mobile-menu-toggle { + font: inherit; +} + +/* Header */ +.site-header { + position: sticky; + top: 0; + z-index: 100; +} + +.nav { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--space-4, 1rem); + max-width: var(--max-width, 1200px); + margin-inline: auto; + padding: var(--space-4, 1rem); +} + +.nav-links { + display: flex; + gap: var(--space-4, 1rem); +} + +.nav-actions { + display: flex; + align-items: center; + gap: var(--space-2, 0.5rem); +} + +/* Docs layout - two column */ +.docs-layout { + display: grid; + grid-template-columns: var(--sidebar-width, 250px) 1fr; + max-width: var(--max-width, 1200px); + margin-inline: auto; + gap: var(--space-8, 2rem); + padding: var(--space-4, 1rem); +} + +.sidebar { + align-self: start; +} + +.sidebar-section { + margin-bottom: var(--space-6, 1.5rem); +} + +.docs-content { + max-width: var(--content-width, 65ch); +} + +/* Keep content media inside the theme's content columns. Scoped to theme + containers so the host site's images elsewhere are never affected. */ +.docs-content img, +.blog-post img { + max-width: 100%; +} + +/* Blog layout */ +.blog-post { + max-width: var(--content-width, 65ch); + margin-inline: auto; + padding: var(--space-4, 1rem); +} + +.blog-container { + width: 100%; +} + +.blog-post-header { + margin-bottom: var(--space-8, 2rem); +} + +.blog-post-tags { + display: flex; + flex-wrap: wrap; + gap: var(--space-2, 0.5rem); + margin-top: var(--space-4, 1rem); +} + +.blog-post-footer { + margin-top: var(--space-8, 2rem); + padding-top: var(--space-4, 1rem); + text-align: center; +} + +/* Docs navigation footer */ +.docs-nav-footer { + display: flex; + justify-content: space-between; + margin-top: var(--space-8, 2rem); + padding-top: var(--space-4, 1rem); +} + +/* Footer */ +.site-footer { + margin-top: auto; +} + +.footer-content { + max-width: var(--max-width, 1200px); + margin-inline: auto; + padding: var(--space-8, 2rem) var(--space-4, 1rem); +} + +.footer-grid { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); + gap: var(--space-8, 2rem); +} + +.footer-bottom { + margin-top: var(--space-8, 2rem); + padding-top: var(--space-4, 1rem); + text-align: center; +} + +/* Language dropdown */ +.language-switcher { + position: relative; +} + +.language-dropdown { + display: none; + position: absolute; + top: 100%; + right: 0; + min-width: 120px; + z-index: 200; + list-style: none; + margin: 0; + padding: 0; +} + +.language-btn[aria-expanded="true"] + .language-dropdown { + display: block; +} + +/* Mobile menu toggle */ +.mobile-menu-toggle { + display: none; + flex-direction: column; + gap: 4px; + background: none; + border: none; + cursor: pointer; + padding: var(--space-2, 0.5rem); +} + +.mobile-menu-toggle span { + display: block; + width: 24px; + height: 2px; + background: currentColor; +} + +/* Mobile responsive */ +@media (max-width: 768px) { + .nav-links { + display: none; + position: absolute; + top: 100%; + left: 0; + right: 0; + flex-direction: column; + padding: var(--space-4, 1rem); + } + + .nav-links.open { + display: flex; + } + + .mobile-menu-toggle { + display: flex; + } + + .docs-layout { + grid-template-columns: 1fr; + } + + .sidebar { + position: fixed; + top: var(--header-height, 60px); + left: 0; + width: var(--sidebar-width, 250px); + height: calc(100vh - var(--header-height, 60px)); + transform: translateX(-100%); + transition: transform 0.3s ease; + z-index: 50; + } + + .sidebar.open { + transform: translateX(0); + } +} diff --git a/website/_site/techdoc/css/reset.css b/website/_site/techdoc/css/reset.css new file mode 100644 index 0000000..bce8768 --- /dev/null +++ b/website/_site/techdoc/css/reset.css @@ -0,0 +1,41 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ HOW TO CUSTOMIZE CSS: ║ + * ║ 1. ALL visual styling goes in YOUR site's styles.css ║ + * ║ 2. Override any techdoc CSS with higher specificity ║ + * ║ 3. Use CSS custom properties (--var-name) for theming ║ + * ║ ║ + * ║ Example in your styles.css: ║ + * ║ .nav { background: var(--color-bg); } // override nav bg ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * techdoc reset.css + * Deliberately minimal so the theme NEVER clobbers the consuming site's CSS. + * + * This file intentionally contains NO global content overrides: + * - NO `* { margin: 0; padding: 0 }` (would wipe the host site's spacing) + * - NO `ul, ol { list-style: none }` (would strip bullets from host content) + * - NO line-height / font-smoothing / overflow-wrap (typography is the host's) + * - NO img / table / form element overrides (content is the host's) + * + * The theme resets ONLY the structural elements it actually owns (nav, sidebar, + * footer lists, theme buttons). Those scoped resets live in layout.css. The + * single global rule below is box-sizing, which every consuming site expects, + * is required by techdoc's grid/flex layout, and is overridable per-element. + */ + +*, +*::before, +*::after { + box-sizing: border-box; +} + +/* Prevent iOS text-size inflation. Not a visual/typographic choice. */ +html { + -webkit-text-size-adjust: 100%; +} diff --git a/website/_site/techdoc/css/utilities.css b/website/_site/techdoc/css/utilities.css new file mode 100644 index 0000000..490a6a3 --- /dev/null +++ b/website/_site/techdoc/css/utilities.css @@ -0,0 +1,58 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ TO ADD UTILITIES: Create them in YOUR site's styles.css ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * techdoc utilities.css + * Accessibility helpers - NO colors, NO decorative styles + */ + +/* Screen reader only */ +.sr-only { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + white-space: nowrap; + border: 0; +} + +/* Skip link - visible on focus */ +.skip-link { + position: absolute; + top: -100%; + left: 50%; + transform: translateX(-50%); + z-index: 1000; + padding: var(--space-2, 0.5rem) var(--space-4, 1rem); +} + +.skip-link:focus { + top: var(--space-2, 0.5rem); +} + +/* Focus visible */ +:focus-visible { + outline: 2px solid currentColor; + outline-offset: 2px; +} + +/* Reduced motion */ +@media (prefers-reduced-motion: reduce) { + *, + *::before, + *::after { + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + scroll-behavior: auto !important; + } +} diff --git a/website/_site/techdoc/js/language-switcher.js b/website/_site/techdoc/js/language-switcher.js new file mode 100644 index 0000000..3e5fdee --- /dev/null +++ b/website/_site/techdoc/js/language-switcher.js @@ -0,0 +1,31 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ TO OVERRIDE: Create src/assets/js/custom.js in YOUR site and ║ + * ║ redefine initLanguageSwitcher() or add your own event listeners. ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * Language switcher - handles dropdown toggle and outside click + */ +export function initLanguageSwitcher() { + const btn = document.querySelector(".language-btn"); + const dropdown = document.querySelector(".language-dropdown"); + if (!btn || !dropdown) { + return; + } + btn.addEventListener("click", () => { + const expanded = btn.getAttribute("aria-expanded") === "true"; + btn.setAttribute("aria-expanded", !expanded); + }); + + document.addEventListener("click", (e) => { + if (!e.target.closest(".language-switcher")) { + btn.setAttribute("aria-expanded", "false"); + } + }); +} +// SYMLINK TEST - This proves changes flow through! diff --git a/website/_site/techdoc/js/main.js b/website/_site/techdoc/js/main.js new file mode 100644 index 0000000..6b79e24 --- /dev/null +++ b/website/_site/techdoc/js/main.js @@ -0,0 +1,25 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ HOW TO CUSTOMIZE: ║ + * ║ 1. Create your own JS file in YOUR site: src/assets/js/custom.js ║ + * ║ 2. Add in your layout ║ + * ║ (use {% block scripts %} in base.njk) ║ + * ║ 3. Your custom.js can override any behavior by running AFTER this ║ + * ║ ║ + * ║ NEED TO MODIFY techdoc ITSELF? ║ + * ║ Edit the source in: techdoc/assets/js/ ║ + * ║ Then run: ./update-techdoc.sh to sync changes ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + */ +import { initThemeToggle } from "./theme-toggle.js"; +import { initMobileMenu } from "./mobile-menu.js"; +import { initLanguageSwitcher } from "./language-switcher.js"; + +initThemeToggle(); +initMobileMenu(); +initLanguageSwitcher(); diff --git a/website/_site/techdoc/js/mobile-menu.js b/website/_site/techdoc/js/mobile-menu.js new file mode 100644 index 0000000..572af5c --- /dev/null +++ b/website/_site/techdoc/js/mobile-menu.js @@ -0,0 +1,29 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ TO OVERRIDE: Create src/assets/js/custom.js in YOUR site and ║ + * ║ redefine initMobileMenu() or add your own event listeners. ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * Mobile menu toggle - handles sidebar visibility on mobile + */ +export function initMobileMenu() { + const toggle = document.getElementById("mobile-menu-toggle"); + const sidebar = document.querySelector(".sidebar, .docs-sidebar"); + const navLinks = document.querySelector(".nav-links"); + if (!toggle) { + return; + } + + toggle.addEventListener("click", () => { + const expanded = toggle.getAttribute("aria-expanded") === "true"; + toggle.setAttribute("aria-expanded", String(!expanded)); + sidebar?.classList.toggle("open"); + navLinks?.classList.toggle("open"); + document.body.classList.toggle("menu-open"); + }); +} diff --git a/website/_site/techdoc/js/theme-toggle.js b/website/_site/techdoc/js/theme-toggle.js new file mode 100644 index 0000000..7f3b1ce --- /dev/null +++ b/website/_site/techdoc/js/theme-toggle.js @@ -0,0 +1,26 @@ +/** + * ╔══════════════════════════════════════════════════════════════════════════╗ + * ║ ⚠️ DO NOT MODIFY THIS FILE DIRECTLY! ⚠️ ║ + * ╠══════════════════════════════════════════════════════════════════════════╣ + * ║ This file is part of the techdoc npm package. ║ + * ║ Changes here will be OVERWRITTEN when techdoc is updated. ║ + * ║ ║ + * ║ TO OVERRIDE: Create src/assets/js/custom.js in YOUR site and ║ + * ║ redefine initThemeToggle() or add your own event listeners. ║ + * ╚══════════════════════════════════════════════════════════════════════════╝ + * + * Theme toggle - switches between light/dark modes + */ +export function initThemeToggle() { + const toggle = document.getElementById("theme-toggle"); + if (!toggle) { + return; + } + + toggle.addEventListener("click", () => { + const current = document.documentElement.getAttribute("data-theme"); + const next = current === "dark" ? "light" : "dark"; + document.documentElement.setAttribute("data-theme", next); + localStorage.setItem("theme", next); + }); +} From 029e583a3a7d6f4620026f537ef2818650accbd9 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:34:28 +1100 Subject: [PATCH 26/39] forget frees the closed document's diagnostics before it returns; the reference server forgets on didClose (#52) Builds on d2a22c4 and closes three gaps that cross-check tests found: - The retired memo stayed alive until a later pull, then until Salsa's next revision. forget now retires the document at once whenever no query holds the lock (try_lock, so it still never waits behind compiler work; otherwise the next query retires it first). One write to the retired slot then starts the next revision, which frees the replaced memo. forget_frees_the_closed_documents_diagnostics_before_it_returns checks this with a Weak, and fails if either step is removed. - A retired slot was marked by an empty URI, so a pull of "" returned a clean report without analysis. A slot is now marked by an open flag. - The reference server still called clear() on didClose. It now calls forget(uri), so the diagnostic_reference suites exercise forget. Also tested: forget returns while a compiler query runs, and the queued release applies before the next pull. All 197 lspkit-server tests pass on Windows. Co-Authored-By: Claude Opus 5.5 --- .../diagnostic-reference/session/handlers.rs | 6 +- crates/lspkit-server/src/pull.rs | 48 ++++++++--- crates/lspkit-server/tests/pull_forget.rs | 80 +++++++++++++++++++ docs/specs/LSP-PULL-SPEC.md | 21 +++-- 4 files changed, 133 insertions(+), 22 deletions(-) diff --git a/crates/lspkit-server/examples/diagnostic-reference/session/handlers.rs b/crates/lspkit-server/examples/diagnostic-reference/session/handlers.rs index fcf4229..293fa4a 100644 --- a/crates/lspkit-server/examples/diagnostic-reference/session/handlers.rs +++ b/crates/lspkit-server/examples/diagnostic-reference/session/handlers.rs @@ -100,9 +100,11 @@ pub(super) fn close_document(server: &Server, params: Value) { tracing::warn!("recovering poisoned source registry to release closed document"); poisoned.into_inner() }); - let _ = documents.remove(params.text_document.uri.as_str()); + let uri = params.text_document.uri.as_str(); + let _ = documents.remove(uri); drop(documents); - if let Err(error) = server.pull.clear() { + // [LSP-PULL-FORGET] Only the closed document's memo goes; open ones stay warm. + if let Err(error) = server.pull.forget(uri) { tracing::warn!(%error, "closed document memo release failed"); } } diff --git a/crates/lspkit-server/src/pull.rs b/crates/lspkit-server/src/pull.rs index a384aab..69492dd 100644 --- a/crates/lspkit-server/src/pull.rs +++ b/crates/lspkit-server/src/pull.rs @@ -7,7 +7,7 @@ use std::collections::HashMap; use std::sync::atomic::{AtomicU64, Ordering}; -use std::sync::{Arc, Mutex}; +use std::sync::{Arc, Mutex, TryLockError}; use lsp_types::Diagnostic; use salsa::Setter; @@ -116,6 +116,9 @@ struct DocumentInput { uri: String, version: i32, retry_revision: u64, + /// `false` once retired. A flag, not an empty URI, so a consumer's own + /// `""` is still analyzed. [LSP-PULL-FORGET] + open: bool, } #[salsa::tracked(returns(clone))] @@ -123,10 +126,11 @@ fn analyze(db: &dyn DiagnosticDb, document: DocumentInput, workspace: WorkspaceI let _generation = workspace.generation(db); let _version = document.version(db); let _retry = document.retry_revision(db); - match document.uri(db).as_str() { + if *document.open(db) { + db.analyze(document.uri(db)) + } else { // A retired slot holds no document: its memo releases the old report. - "" => Ok(Arc::default()), - uri => db.analyze(uri), + Ok(Arc::default()) } } @@ -167,9 +171,10 @@ impl QueryState { let document = match self.retired.pop() { Some(retired) => { let _empty = retired.set_uri(&mut self.database).to(uri.to_owned()); + let _retired = retired.set_open(&mut self.database).to(true); retired } - None => DocumentInput::new(&self.database, uri.to_owned(), 0, 0), + None => DocumentInput::new(&self.database, uri.to_owned(), 0, 0, true), }; let _absent = self.documents.insert(uri.to_owned(), document); document @@ -183,11 +188,22 @@ impl QueryState { .collect(); for document in closed { let _closed_uri = document.set_uri(&mut self.database).to(String::new()); + let _open = document.set_open(&mut self.database).to(false); let _released = analyze(&self.database, document, self.workspace); + // Salsa frees a replaced memo only when its next revision starts; + // a write to this retired slot alone starts it. + self.retry(document); self.retired.push(document); } } + /// Retire every URI queued in `pending`. + fn forget_pending(&mut self, pending: &Mutex>) -> Result<(), PullError> { + let uris = std::mem::take(&mut *pending.lock().map_err(poisoned)?); + self.forget(&uris); + Ok(()) + } + /// Get or create the document handle, then refresh its editor version. fn document(&mut self, uri: &str, version: i32) -> DocumentInput { let document = match self.documents.get(uri) { @@ -304,18 +320,26 @@ impl PullStore { /// Release one closed document's input and memos; every other memo stays /// warm and no snapshot is superseded. [LSP-PULL-FORGET] /// - /// Never waits behind compiler work: the next query retires the document, - /// so a later pull of `uri` recomputes. Forgetting an unknown or already - /// forgotten URI is `Ok`. + /// When no query holds the lock, the document's diagnostics are freed + /// before this returns. It never waits behind compiler work: while a query + /// runs, the release is queued and the next query retires the document + /// first. A later pull of `uri` recomputes. Forgetting an unknown or + /// already forgotten URI is `Ok`. /// /// # Errors - /// Returns an error if the pending-forget lock was poisoned. + /// Returns an error if a store lock was poisoned. pub fn forget(&self, uri: &str) -> Result<(), PullError> { self.forgotten .lock() .map_err(poisoned)? .push(uri.to_owned()); - Ok(()) + let shared = Arc::clone(&*self.query.lock().map_err(poisoned)?); + let applied = match shared.try_lock() { + Ok(mut query) => query.forget_pending(&self.forgotten), + Err(TryLockError::WouldBlock) => Ok(()), + Err(TryLockError::Poisoned(source)) => Err(poisoned(source).into()), + }; + applied } /// Supersede in-flight work and invalidate inter-file dependencies. @@ -382,9 +406,7 @@ impl PullStore { uncancelled(cancel)?; let shared = Arc::clone(&*self.query.lock().map_err(poisoned)?); let mut query = shared.lock().map_err(poisoned)?; - query.forget(&std::mem::take( - &mut *self.forgotten.lock().map_err(poisoned)?, - )); + query.forget_pending(&self.forgotten)?; let revision = self.query_revision(&shared)?; let generation = self.generation.load(Ordering::Acquire); let report = query.compute(uri, version, revision, generation, cancel)?; diff --git a/crates/lspkit-server/tests/pull_forget.rs b/crates/lspkit-server/tests/pull_forget.rs index 9194c77..e296e28 100644 --- a/crates/lspkit-server/tests/pull_forget.rs +++ b/crates/lspkit-server/tests/pull_forget.rs @@ -109,3 +109,83 @@ fn forget_is_idempotent_and_a_recycled_input_never_replays_old_truth() { let _cold = pull(&store, C); assert_eq!(calls_for(&calls, C), 2, "clear recomputes every document"); } + +#[test] +fn forget_frees_the_closed_documents_diagnostics_before_it_returns() { + let (store, _calls) = counting_store(); + let held = |uri| { + let pulled = store.diagnostics(uri, 1); + assert!(pulled.is_ok(), "{uri}: {pulled:?}"); + pulled.map(|report| Arc::downgrade(&report.items)).ok() + }; + let (a, b) = (held(A), held(B)); + let strong = |weak: &Option>>| { + weak.as_ref() + .map_or(usize::MAX, std::sync::Weak::strong_count) + }; + assert_eq!((strong(&a), strong(&b)), (1, 1), "only the memos hold them"); + store.forget(A).expect("forget A"); + assert_eq!( + strong(&a), + 0, + "A's diagnostics are freed with no later pull" + ); + assert_eq!(strong(&b), 1, "B's memo is untouched"); +} + +#[test] +fn forget_returns_while_a_compiler_query_runs_and_the_next_pull_applies_it() { + let started = Arc::new(std::sync::Barrier::new(2)); + let release = Arc::new(std::sync::Barrier::new(2)); + let calls: Calls = Arc::default(); + let (in_flight, resume, counted) = ( + Arc::clone(&started), + Arc::clone(&release), + Arc::clone(&calls), + ); + let store = PullStore::new(Arc::new(move |uri| { + let seen = counted.lock().map(|mut calls| { + let count = calls.entry(uri.to_owned()).or_default(); + *count += 1; + *count + }); + if uri == B && matches!(seen, Ok(1)) { + let _started = in_flight.wait(); + let _released = resume.wait(); + } + Ok(Arc::new(vec![Diagnostic { + message: uri.to_owned(), + ..Diagnostic::default() + }])) + })); + let _a = pull(&store, A); + let worker = { + let store = store.clone(); + std::thread::spawn(move || store.diagnostics(B, 1).map(|report| report.result_id)) + }; + let _computing = started.wait(); + assert_eq!( + store.forget(A), + Ok(()), + "forget never waits for B's compiler" + ); + let _done = release.wait(); + assert!(matches!(worker.join(), Ok(Ok(_))), "B completes"); + let _reopened = pull(&store, A); + assert_eq!( + calls_for(&calls, A), + 2, + "the queued forget applied before A's pull" + ); +} + +#[test] +fn an_empty_uri_is_analyzed_never_mistaken_for_a_forgotten_slot() { + let (store, calls) = counting_store(); + let _empty = pull(&store, ""); + assert_eq!( + calls_for(&calls, ""), + 1, + "the compiler decides what \"\" means" + ); +} diff --git a/docs/specs/LSP-PULL-SPEC.md b/docs/specs/LSP-PULL-SPEC.md index 18716fc..75a3832 100644 --- a/docs/specs/LSP-PULL-SPEC.md +++ b/docs/specs/LSP-PULL-SPEC.md @@ -27,13 +27,20 @@ until they finish; they return superseded. Clearing never waits behind compiler `PullStore::forget(uri)` releases one closed document. Every other document's memo stays warm, and no snapshot is superseded. Salsa input slots cannot be deleted, so -the next query retires the document's input: its URI is emptied, its memo is -recomputed to an empty report (the analyzer never sees a retired slot), and the -slot is reused by the next newly opened document. Slots therefore never outnumber -the documents open at once, and open/forget cycles of distinct URIs free exactly -the heap they allocate. `forget` queues the URI behind its own lock, so a close -never waits behind compiler work. A later pull of a forgotten URI recomputes. -Forgetting an unknown or already forgotten URI is `Ok`. +the document's input is retired instead: +- Its URI is emptied and it is flagged closed (a flag, not the empty URI, so a + consumer's own `""` is still analyzed). +- Its memo is recomputed to an empty report, and the analyzer never sees a retired slot. +- One write to the retired slot starts Salsa's next revision, which frees the + replaced memo. +- The slot is reused by the next newly opened document. + +`forget` retires the document before it returns, so its diagnostics are freed at +once, whenever no query holds the lock. It never waits behind compiler work: while +a query runs, the URI is queued behind its own lock and the next query retires it +first. Slots never outnumber the documents open at once, and open/forget cycles of +distinct URIs free exactly the heap they allocate. A later pull of a forgotten URI +recomputes. Forgetting an unknown or already forgotten URI is `Ok`. ## [LSP-PULL-CONCURRENCY] Nonblocking Invalidation From 950c04c096ae7eeb801520d9887ca00b031677a1 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:35:45 +1100 Subject: [PATCH 27/39] PullStore::forget: a pull retires closes queued during it; queued closes are a set (#52) On top of 029e583: closes that arrive while a pull holds the state retire as that pull releases it, not at some later pull, and repeated closes are one queued entry. Heap tests cover idle close-all, a close during an in-flight pull and repeated closes; each fix line has a killing mutant. --- crates/lspkit-server/src/pull.rs | 33 +++++-- .../lspkit-server/tests/pull_forget_heap.rs | 92 ++++++++++++++++++- docs/plans/issue-fix-evidence-21-26-48-49.md | 17 ++++ docs/specs/LSP-PULL-SPEC.md | 5 +- 4 files changed, 138 insertions(+), 9 deletions(-) diff --git a/crates/lspkit-server/src/pull.rs b/crates/lspkit-server/src/pull.rs index 69492dd..0892b9b 100644 --- a/crates/lspkit-server/src/pull.rs +++ b/crates/lspkit-server/src/pull.rs @@ -5,7 +5,7 @@ //! lock-free supersession/generation counters; protocol-side invalidation never //! waits behind a running compiler query. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::{Arc, Mutex, TryLockError}; @@ -181,7 +181,7 @@ impl QueryState { } /// Retire each closed document: drop its URI and memo, keep its slot. - fn forget(&mut self, uris: &[String]) { + fn forget(&mut self, uris: &HashSet) { let closed: Vec = uris .iter() .filter_map(|uri| self.documents.remove(uri)) @@ -198,7 +198,7 @@ impl QueryState { } /// Retire every URI queued in `pending`. - fn forget_pending(&mut self, pending: &Mutex>) -> Result<(), PullError> { + fn forget_pending(&mut self, pending: &Mutex>) -> Result<(), PullError> { let uris = std::mem::take(&mut *pending.lock().map_err(poisoned)?); self.forget(&uris); Ok(()) @@ -273,7 +273,7 @@ pub struct PullStore { generation: Arc, /// Closed URIs the next query retires, so a close never waits behind the /// compiler. Drained by every query. [LSP-PULL-FORGET] - forgotten: Arc>>, + forgotten: Arc>>, } impl PullStore { @@ -329,10 +329,18 @@ impl PullStore { /// # Errors /// Returns an error if a store lock was poisoned. pub fn forget(&self, uri: &str) -> Result<(), PullError> { - self.forgotten + let _queued = self + .forgotten .lock() .map_err(poisoned)? - .push(uri.to_owned()); + .insert(uri.to_owned()); + self.retire_forgotten() + } + + /// Retire every queued close now, unless a query holds the state: that + /// query calls this again once it releases the state, so none waits for a + /// later pull. Lock order: database owner, query state, then the queue. + fn retire_forgotten(&self) -> Result<(), PullError> { let shared = Arc::clone(&*self.query.lock().map_err(poisoned)?); let applied = match shared.try_lock() { Ok(mut query) => query.forget_pending(&self.forgotten), @@ -404,6 +412,19 @@ impl PullStore { cancel: &CancellationToken, ) -> Result { uncancelled(cancel)?; + let pulled = self.pull_locked(uri, version, cancel); + // Closes that arrived while this query held the state retire now. + self.retire_forgotten()?; + pulled + } + + /// One pull under the query lock, retiring queued closes first. + fn pull_locked( + &self, + uri: &str, + version: i32, + cancel: &CancellationToken, + ) -> Result { let shared = Arc::clone(&*self.query.lock().map_err(poisoned)?); let mut query = shared.lock().map_err(poisoned)?; query.forget_pending(&self.forgotten)?; diff --git a/crates/lspkit-server/tests/pull_forget_heap.rs b/crates/lspkit-server/tests/pull_forget_heap.rs index b9277ae..95b8c2a 100644 --- a/crates/lspkit-server/tests/pull_forget_heap.rs +++ b/crates/lspkit-server/tests/pull_forget_heap.rs @@ -3,7 +3,7 @@ //! sibling tests. #![cfg(feature = "pull")] -use std::sync::Arc; +use std::sync::{Arc, Barrier}; use lspkit_server::pull::{PullError, PullStore}; @@ -15,6 +15,46 @@ const WARM_CYCLES: usize = 1_000; /// Measured cycles, each on a URI never seen before. const CYCLES: usize = 1_000; +/// Documents left open, then closed while the store is idle. +const OPEN_DOCUMENTS: usize = 32; +/// Heap each open document's report owns. +const REPORT_BYTES: usize = 64 * 1024; +/// Closes of one URI with no pull in between. +const REPEATED_CLOSES: usize = 1_000; + +/// A store whose every report owns `REPORT_BYTES` of heap. +fn heavy_store() -> PullStore { + PullStore::new(Arc::new(|_uri| { + Ok(Arc::new(vec![lsp_types::Diagnostic { + message: "x".repeat(REPORT_BYTES), + ..lsp_types::Diagnostic::default() + }])) + })) +} + +/// The document whose analysis is held in flight. +const SLOW: &str = "file:///repo/slow.cs"; + +/// A heavy store whose analysis of `SLOW` waits on `started` then `release`. +fn held_store(started: &Arc, release: &Arc) -> PullStore { + let (started, release) = (Arc::clone(started), Arc::clone(release)); + PullStore::new(Arc::new(move |uri| { + if uri == SLOW { + let _started = started.wait(); + let _released = release.wait(); + } + Ok(Arc::new(vec![lsp_types::Diagnostic { + message: "x".repeat(REPORT_BYTES), + ..lsp_types::Diagnostic::default() + }])) + })) +} + +/// The URI of open document `index`. +fn open_uri(index: usize) -> String { + format!("file:///repo/open-{index:06}.cs") +} + /// Open, pull and close `count` distinct documents starting at `first`. fn cycles(store: &PullStore, first: usize, count: usize) -> Result<(), PullError> { (first..first + count).try_for_each(|index| { @@ -38,4 +78,54 @@ fn open_forget_cycles_of_distinct_uris_release_their_heap() { let mut outcome = Ok(()); state::assert_releases_heap(|| outcome = cycles(&store, WARM_CYCLES, CYCLES)); outcome.expect("measured cycles"); + + // Close every tab and go idle: the reports are freed by the closes + // themselves, not by some later pull. + let heavy = heavy_store(); + for index in 0..OPEN_DOCUMENTS { + let _open = heavy + .diagnostics(&open_uri(index), 1) + .expect("an open pull"); + } + let uris: Vec = (0..OPEN_DOCUMENTS).map(open_uri).collect(); + let mut closed = Ok(()); + let stats = state::heap_change(|| { + closed = uris.iter().try_for_each(|uri| heavy.forget(uri)); + }); + closed.expect("idle closes"); + assert!( + stats.bytes_deallocated >= OPEN_DOCUMENTS * REPORT_BYTES, + "closing {OPEN_DOCUMENTS} idle documents freed {} of their {} report bytes", + stats.bytes_deallocated, + OPEN_DOCUMENTS * REPORT_BYTES + ); + + // A close that arrives while a pull holds the state is retired by that + // pull as it finishes, with no later pull. + let (started, release) = (Arc::new(Barrier::new(2)), Arc::new(Barrier::new(2))); + let held = held_store(&started, &release); + // The caller drops its copy, so only the memo still owns the report. + drop(held.diagnostics(&open_uri(0), 1).expect("an open pull")); + let worker = { + let held = held.clone(); + std::thread::spawn(move || held.diagnostics(SLOW, 1)) + }; + let _in_flight = started.wait(); + held.forget(&open_uri(0)).expect("a close during a pull"); + let stats = state::heap_change(|| { + let _release = release.wait(); + let _slow = worker.join(); + }); + assert!( + stats.bytes_deallocated >= REPORT_BYTES, + "a close during a pull freed {} of its {REPORT_BYTES} report bytes", + stats.bytes_deallocated + ); + + // Repeated closes with no pull in between keep nothing queued. + let mut repeated = Ok(()); + state::assert_releases_heap(|| { + repeated = (0..REPEATED_CLOSES).try_for_each(|_| heavy.forget(&open_uri(0))); + }); + repeated.expect("repeated closes"); } diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 0f6d026..180e939 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -278,3 +278,20 @@ a_short_body_allocates_what_arrived_not_what_was_claimed ... FAILED (tests/jso ``` Green once every header line is read through `take(budget)`: `tests/jsonrpc.rs` 21/21 and `jsonrpc_frame_heap` 1/1, each under 64 KiB. The test covers one endless line, endless `X: y` lines, a block exactly at the cap reaching the body, and one byte over it. + +### #52 follow-up: closes made during a pull, and repeated closes + +SharpLsp1 found that deleting the release `analyze` call in `d2a22c4` left all tests green. `029e583` (Windows agent) then retired documents on close via `try_lock`, using an `open` flag and a retry write. On top of it, this change retires closes queued during an in-flight pull as soon as that pull releases the state, instead of waiting for a later pull, and makes the queue a set, so repeated closes are one entry. `pull_forget_heap` asserts that closing 32 idle 64 KiB documents frees every report byte, that a close during an in-flight pull is freed by that pull as it finishes, and that 1000 repeated closes keep no heap. Red at `d2a22c4`: + +```text +closing 32 idle documents freed 0 of their 2097152 report bytes +``` + +On the merged code, each fix line mutated on its own turns the test red: + +```text +release `analyze` removed → freed 7072 of their 2097152 report bytes +retry write removed → freed 2050592 of their 2097152 report bytes +retire-on-close removed → freed 1532 of their 2097152 report bytes +post-query retire removed → a close during a pull freed 160 of its 65536 report bytes +``` diff --git a/docs/specs/LSP-PULL-SPEC.md b/docs/specs/LSP-PULL-SPEC.md index 75a3832..7024042 100644 --- a/docs/specs/LSP-PULL-SPEC.md +++ b/docs/specs/LSP-PULL-SPEC.md @@ -37,8 +37,9 @@ the document's input is retired instead: `forget` retires the document before it returns, so its diagnostics are freed at once, whenever no query holds the lock. It never waits behind compiler work: while -a query runs, the URI is queued behind its own lock and the next query retires it -first. Slots never outnumber the documents open at once, and open/forget cycles of +a query runs, the URI waits in a set behind its own lock (repeated closes are one +entry), and that query retires it as it releases the state, so closing every tab +during a pull and going idle still frees every report. Slots never outnumber the documents open at once, and open/forget cycles of distinct URIs free exactly the heap they allocate. A later pull of a forgotten URI recomputes. Forgetting an unknown or already forgotten URI is `Ok`. From 1f05b4061b0a03dedd2ee9e5cd5c24bc05ac710a Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:37:42 +1100 Subject: [PATCH 28/39] Test that forget never runs the compiler on the closed document (#52) --- crates/lspkit-server/tests/pull_forget.rs | 15 +++++++++++++++ docs/plans/issue-fix-evidence-21-26-48-49.md | 2 ++ 2 files changed, 17 insertions(+) diff --git a/crates/lspkit-server/tests/pull_forget.rs b/crates/lspkit-server/tests/pull_forget.rs index e296e28..046fb84 100644 --- a/crates/lspkit-server/tests/pull_forget.rs +++ b/crates/lspkit-server/tests/pull_forget.rs @@ -33,6 +33,14 @@ fn counting_store() -> (PullStore, Calls) { (store, calls) } +/// How many times the compiler ran, over every URI. +fn total_calls(calls: &Calls) -> usize { + match calls.lock() { + Ok(counts) => counts.values().sum(), + Err(poisoned) => poisoned.into_inner().values().sum(), + } +} + /// How many times the compiler analyzed `uri`. fn calls_for(calls: &Calls, uri: &str) -> usize { let counts = match calls.lock() { @@ -70,8 +78,15 @@ fn forgetting_one_document_keeps_every_other_memo_warm() { assert_eq!(calls_for(&calls, uri), 1, "{uri} is memoized"); } let revision = store.revision(); + let before = total_calls(&calls); store.forget(A).expect("forget a closed document"); assert_eq!(store.revision(), revision, "forgetting supersedes nothing"); + assert_eq!( + total_calls(&calls), + before, + "a close never runs the compiler" + ); + assert_eq!(calls_for(&calls, ""), 0, "a retired slot is never analyzed"); for (uri, id) in [(B, id_b), (C, id_c)] { assert_eq!(pull(&store, uri), id, "{uri} keeps its snapshot"); assert_eq!(calls_for(&calls, uri), 1, "{uri} stays a cache hit"); diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 180e939..588107a 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -295,3 +295,5 @@ retry write removed → freed 2050592 of their 2097152 report bytes retire-on-close removed → freed 1532 of their 2097152 report bytes post-query retire removed → a close during a pull freed 160 of its 65536 report bytes ``` + +`set_open(..).to(false)` removed → `forgetting_one_document_keeps_every_other_memo_warm` fails with "a close never runs the compiler: left 4, right 3" (SharpLsp1's mutant, now killed). From beca2c6246c54d0abe733a2be73bd4db1a10e5fe Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:44:38 +1100 Subject: [PATCH 29/39] Release the .NET engine, fixtures, specs and test-support as assets (#42) Consumers no longer need a source checkout or the release tarball. scripts/release-assets.sh adds two kinds of asset to the GitHub Release: - lsp-profiler-dotnet-engine--.tar.gz for linux-x64, linux-arm64, osx-x64, osx-arm64, win-x64 and win-arm64: the framework-dependent engine lsp-profiler-dotnet launches. Point LSP_PROFILER_DOTNET_ENGINE at the extracted executable. - lspkit-consumer-kit-.tar.gz: dotnet/fixtures (source only), LSP-PROFILER-SPEC.md, LSP-PULL-SPEC.md, test-support/ and scripts/typediagram/run-cli.mjs. release.yml sets up .NET and writes them into DIST, so SHA256SUMS, cosign and the attestations cover them. CI packages linux-x64 and checks both archives' contents, so a broken script fails on a PR, not at tag time. The lsp-profiler-dotnet e2e support honours LSP_PROFILER_DOTNET_ENGINE, so the same suites run against a released engine. On Windows, the extracted win-x64 asset passes every .NET e2e session. lsp-profiler-ui gains a CHANGELOG.md (packed) recording the breaking 0.4.0 change: buildFlamegraphHtml, apply{Profile,Memory,Leak}Decorations and removeTestDir return Promises. Spec: [REL-CONSUMER-ASSETS]. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 14 +++++ .github/workflows/release.yml | 13 ++++ .../lsp-profiler-dotnet/tests/support/mod.rs | 14 +++-- docs/specs/lspkit-spec.md | 5 ++ packages/lsp-profiler-ui/CHANGELOG.md | 17 +++++ packages/lsp-profiler-ui/package.json | 1 + scripts/release-assets.sh | 62 +++++++++++++++++++ 7 files changed, 121 insertions(+), 5 deletions(-) create mode 100644 packages/lsp-profiler-ui/CHANGELOG.md create mode 100644 scripts/release-assets.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f41af53..8692693 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -108,6 +108,20 @@ jobs: - name: Build run: make build + # release.yml runs this script only on a tag; packaging one runtime id + # here keeps a broken script from surfacing only at release time. + # [REL-CONSUMER-ASSETS] + - name: Release consumer assets (linux-x64) + run: | + set -eu + sh scripts/release-assets.sh ci "${RUNNER_TEMP}/assets" linux-x64 + tar -tzf "${RUNNER_TEMP}/assets/lsp-profiler-dotnet-engine-ci-linux-x64.tar.gz" | grep -qx './lsp-profiler-dotnet-engine' + kit=$(tar -tzf "${RUNNER_TEMP}/assets/lspkit-consumer-kit-ci.tar.gz") + for want in dotnet/fixtures/HotLeakApp/Program.cs docs/specs/LSP-PROFILER-SPEC.md docs/specs/LSP-PULL-SPEC.md test-support/state.rs scripts/typediagram/run-cli.mjs; do + printf '%s\n' "$kit" | grep -qx "lspkit-consumer-kit-ci/$want" + done + if printf '%s\n' "$kit" | grep -q '/bin/\|/obj/'; then echo "kit ships build output"; exit 1; fi + - name: Upload build artifacts uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 51115f3..d903acb 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -64,6 +64,12 @@ jobs: - name: Install npm + typeDiagram run: npm install -g npm@11.21.1 typediagram@0.11.0 + # Builds the .NET profiler engine release assets (net8.0, rolled + # forward to this SDK's runtime). [REL-CONSUMER-ASSETS] + - uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 + with: + dotnet-version: "10.0.x" + - name: Install version stamper and vuln gate uses: taiki-e/install-action@5488ac5a951645ce95062214902ac4b6bc1a1037 # v2.87.32 with: @@ -138,6 +144,13 @@ jobs: npm run build --prefix packages/lsp-profiler-ui npm pack ./packages/lsp-profiler-ui --pack-destination "${DIST}" + # What consumers would otherwise need a source checkout for: the .NET + # engine per runtime id, and the fixtures, specs and test-support kit. + # They land in DIST, so SHA256SUMS, cosign and the attestations cover + # them like every other asset. [REL-CONSUMER-ASSETS] + - name: Package consumer assets + run: sh scripts/release-assets.sh "${GITHUB_REF_NAME#v}" "${DIST}" + # One CycloneDX SBOM over the whole dependency graph. [SWR-SEC-SBOM] - name: Generate SBOM uses: anchore/sbom-action@66cbf4bc1f1c0d2edc94016e65bc221b6bb0ad6c # v0.24.3 diff --git a/crates/lsp-profiler-dotnet/tests/support/mod.rs b/crates/lsp-profiler-dotnet/tests/support/mod.rs index 309ef6a..5fcda42 100644 --- a/crates/lsp-profiler-dotnet/tests/support/mod.rs +++ b/crates/lsp-profiler-dotnet/tests/support/mod.rs @@ -121,12 +121,16 @@ impl ProfilerEvents for Silent { async fn notify(&self, _method: &'static str, _params: Value) {} } -/// The built engine executable. +/// The engine under test: `LSP_PROFILER_DOTNET_ENGINE` when set, the way a +/// consumer points at a released engine asset, else the source build. pub fn engine() -> PathBuf { - built( - "dotnet/LspProfiler.DotNet.Engine/bin/Release/net8.0/lsp-profiler-dotnet-engine", - "make dotnet", - ) + match std::env::var_os(lsp_profiler_dotnet::engine::ENGINE_ENV) { + Some(released) => PathBuf::from(released), + None => built( + "dotnet/LspProfiler.DotNet.Engine/bin/Release/net8.0/lsp-profiler-dotnet-engine", + "make dotnet", + ), + } } /// The shared service with only the .NET runtime, writing under `output_dir`. diff --git a/docs/specs/lspkit-spec.md b/docs/specs/lspkit-spec.md index 434c6ff..5cec1b7 100644 --- a/docs/specs/lspkit-spec.md +++ b/docs/specs/lspkit-spec.md @@ -146,6 +146,11 @@ lspkit runs a **release-only** regime modelled on [Shipwright](https://github.co Every `uses:` is pinned to a 40-character commit SHA. Workflows default to `permissions: contents: read` and elevate per job. Installs are frozen (`npm ci`, `--locked`), and the release job uses no caches. - **[REL-GITHUB]** The release attaches every crate tarball, every npm tarball, a CycloneDX SBOM and one `SHA256SUMS` over them all, cosign keyless-signed (`SHA256SUMS.sigstore.json`). Build provenance and the SBOM are attested against `SHA256SUMS`, so consumers can run `gh attestation verify --repo Nimblesite/lspkit`. `[SWR-SEC-CHECKSUM]` `[SWR-SEC-PROVENANCE]` `[SWR-SEC-SBOM]` +- **[REL-CONSUMER-ASSETS]** Nothing a consumer needs requires a source checkout. `scripts/release-assets.sh` attaches two more kinds of asset to the release, which `SHA256SUMS`, cosign and the attestations cover like every other asset: + - `lsp-profiler-dotnet-engine--.tar.gz` for `linux-x64`, `linux-arm64`, `osx-x64`, `osx-arm64`, `win-x64` and `win-arm64`: the framework-dependent .NET engine that `lsp-profiler-dotnet` launches. Point `LSP_PROFILER_DOTNET_ENGINE` at the extracted `lsp-profiler-dotnet-engine` executable, or place it beside the language server ([PROF-DOTNET-ENGINE-LOCATE]). + - `lspkit-consumer-kit-.tar.gz`: the profiler fixtures (`dotnet/fixtures`, as source), `LSP-PROFILER-SPEC.md`, `LSP-PULL-SPEC.md`, `test-support/` and `scripts/typediagram/run-cli.mjs`. + + The `lsp-profiler-dotnet` e2e suites honour `LSP_PROFILER_DOTNET_ENGINE`, so they run unchanged against a released engine. - **[REL-OIDC]** crates.io and npm both publish through OIDC Trusted Publishing from `release.yml` in the protected `release` environment. The repo stores no `CARGO_REGISTRY_TOKEN` or `NPM_TOKEN`. npm packages also publish with `--provenance`. `[SWR-SEC-OIDC-PUBLISH]` - **[REL-ORDER]** Crates publish in dependency order: `lsp-profiler`, `lsp-profiler-dotnet`, `lspkit`, `lspkit-server`. `cargo publish` waits for each crate to appear in the index, so no sleeps are needed. The npm package (`@nimblesite/lsp-profiler-ui`) publishes after the crates. Both publish wrappers skip a version that is already on the registry, so a re-run after a failure partway through is safe. - **[REL-METADATA]** Every published crate and npm package declares `license = "MIT"` and a repository. The root `LICENSE-MIT` is staged into each crate (`LICENSE-MIT`) and each npm package (`LICENSE`) at publish time, so the declared license ships with the package. `[SWR-REL-LICENSE]` diff --git a/packages/lsp-profiler-ui/CHANGELOG.md b/packages/lsp-profiler-ui/CHANGELOG.md new file mode 100644 index 0000000..a6191ca --- /dev/null +++ b/packages/lsp-profiler-ui/CHANGELOG.md @@ -0,0 +1,17 @@ +# Changelog + +## Unreleased + +- The profiler's .NET engine, fixtures, specs and test-support ship as GitHub Release assets (`lsp-profiler-dotnet-engine--.tar.gz`, `lspkit-consumer-kit-.tar.gz`), so consumers no longer need a source checkout. [REL-CONSUMER-ASSETS] + +## 0.4.0 + +### Breaking + +These functions now return a `Promise` and must be awaited: + +- `buildFlamegraphHtml(result)` now returns `Promise`. +- `applyProfileDecorations(result)`, `applyMemoryDecorations(result)` and `applyLeakDecorations(result)` now return `Promise`. +- `removeTestDir(dir)` (from `testing`) now returns `Promise`. + +A caller that does not await them gets a pending `Promise` instead of the HTML string, or runs ahead before the decorations are applied or the directory is removed. diff --git a/packages/lsp-profiler-ui/package.json b/packages/lsp-profiler-ui/package.json index a7bb9db..da9ec1a 100644 --- a/packages/lsp-profiler-ui/package.json +++ b/packages/lsp-profiler-ui/package.json @@ -7,6 +7,7 @@ "main": "./out/src/index.js", "types": "./out/src/index.d.ts", "files": [ + "CHANGELOG.md", "out/src", "!out/src/test", "!out/src/debug/test", diff --git a/scripts/release-assets.sh b/scripts/release-assets.sh new file mode 100644 index 0000000..910ef02 --- /dev/null +++ b/scripts/release-assets.sh @@ -0,0 +1,62 @@ +#!/bin/sh +# [REL-CONSUMER-ASSETS] Package what consumers would otherwise need a source +# checkout for (#42), as GitHub Release assets beside the crates and npm package: +# +# lsp-profiler-dotnet-engine--.tar.gz +# The .NET engine `lsp-profiler-dotnet` launches, one per runtime id. +# Framework-dependent (net8.0, RollForward=LatestMajor). Point +# LSP_PROFILER_DOTNET_ENGINE at the extracted executable, or place it +# beside the language server. +# lspkit-consumer-kit-.tar.gz +# The profiler fixtures (dotnet/fixtures), the specs consumers cite +# (LSP-PROFILER-SPEC.md, LSP-PULL-SPEC.md), test-support/ and +# scripts/typediagram/run-cli.mjs. +# +# Usage: scripts/release-assets.sh [rid ...] +set -eu + +if [ "$#" -lt 2 ]; then + echo "usage: $0 [rid ...]" >&2 + exit 2 +fi +version=$1 +dist=$2 +shift 2 +if [ "$#" -eq 0 ]; then + set -- linux-x64 linux-arm64 osx-x64 osx-arm64 win-x64 win-arm64 +fi + +root=$(cd "$(dirname "$0")/.." && pwd) +work=$(mktemp -d) +trap 'rm -rf "$work"' EXIT +mkdir -p "$dist" +dist=$(cd "$dist" && pwd) + +for rid in "$@"; do + out="$work/engine-$rid" + dotnet publish "$root/dotnet/LspProfiler.DotNet.Engine" \ + --configuration Release --runtime "$rid" --self-contained false \ + --output "$out" --nologo + case "$rid" in + win-*) executable=lsp-profiler-dotnet-engine.exe ;; + *) executable=lsp-profiler-dotnet-engine ;; + esac + if [ ! -f "$out/$executable" ]; then + echo "release-assets: $rid publish has no $executable" >&2 + exit 1 + fi + cp "$root/LICENSE-MIT" "$out/LICENSE" + tar -czf "$dist/lsp-profiler-dotnet-engine-$version-$rid.tar.gz" -C "$out" . +done + +kit="$work/lspkit-consumer-kit-$version" +mkdir -p "$kit/dotnet" "$kit/docs/specs" "$kit/scripts/typediagram" +# Fixtures ship as source; their build output never does. +tar -cf - -C "$root/dotnet" --exclude=bin --exclude=obj fixtures | tar -xf - -C "$kit/dotnet" +cp "$root/docs/specs/LSP-PROFILER-SPEC.md" "$root/docs/specs/LSP-PULL-SPEC.md" "$kit/docs/specs/" +cp -R "$root/test-support" "$kit/test-support" +cp "$root/scripts/typediagram/run-cli.mjs" "$kit/scripts/typediagram/" +cp "$root/LICENSE-MIT" "$kit/LICENSE" +tar -czf "$dist/lspkit-consumer-kit-$version.tar.gz" -C "$work" "lspkit-consumer-kit-$version" + +ls -l "$dist" From 1eeb2d875522ba68294b1820ab4d8f3961b62066 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:44:38 +1100 Subject: [PATCH 30/39] Cover the sidecar's first-read failure on Windows with a byte-range lock native_initial_read_failure_stays_visible opens a directory, which only Unix lets a reader open and then fail on (EISDIR). On Windows that branch (inbound.rs next_frame's read error) went uncovered, which put lspkit::sidecar at 98.52% and lspkit at 98.85%, under their 99% floors in make test. The Windows twin holds an exclusive byte-range lock from another process (test-support/windows-oplock/lock.ps1, with readiness read from its state line, never from timing). The open succeeds, and the first read fails with ERROR_LOCK_VIOLATION, which the test pins as "(os error 33)". Co-Authored-By: Claude Opus 5.5 --- .../tests/sidecar_disconnect_session.rs | 43 +++++++++++++++++++ test-support/windows-oplock/lock.ps1 | 11 +++++ 2 files changed, 54 insertions(+) create mode 100644 test-support/windows-oplock/lock.ps1 diff --git a/crates/lspkit/tests/sidecar_disconnect_session.rs b/crates/lspkit/tests/sidecar_disconnect_session.rs index 9a0d2ab..95d71df 100644 --- a/crates/lspkit/tests/sidecar_disconnect_session.rs +++ b/crates/lspkit/tests/sidecar_disconnect_session.rs @@ -110,3 +110,46 @@ async fn native_initial_read_failure_stays_visible() { assert_eq!(events.len(), 2); assert_eq!(at(entry(&events, 0), "/kind"), "error"); } + +#[cfg(windows)] +#[path = "../../../test-support/windows-oplock/owner.rs"] +mod owner; + +/// Windows has no EISDIR. Another process's exclusive byte-range lock lets the +/// open succeed and makes the first read fail with `ERROR_LOCK_VIOLATION`. +#[cfg(windows)] +#[tokio::test] +async fn native_initial_read_failure_stays_visible_on_windows() { + let (events, released) = locked_source_events() + .await + .expect("receive a locked source"); + assert!(released.success(), "the lock holder exits cleanly"); + assert_failure(&events); + assert_eq!(events.len(), 2); + assert_eq!(at(entry(&events, 0), "/kind"), "error"); + let message = at(entry(&events, 0), "/message"); + assert!( + message + .as_str() + .is_some_and(|text| text.contains("(os error 33)")), + "the open succeeded and the first read hit the lock: {message}" + ); +} + +/// Receive a source another process holds under an exclusive byte-range lock, +/// then release the lock. Readiness comes from the holder's state line. +#[cfg(windows)] +async fn locked_source_events() -> TestResult<(Vec, std::process::ExitStatus)> { + let fixture = tempfile::TempDir::new()?; + let path = fixture.path().join("locked.bin"); + std::fs::write(&path, b"locked bytes")?; + let script = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../test-support/windows-oplock/lock.ps1"); + let mut holder = owner::spawn(&script, &path)?; + let stdout = holder.stdout.take().ok_or("lock holder stdout")?; + owner::state(&mut std::io::BufReader::new(stdout), "locked")?; + let source = path.to_str().ok_or("capture path is not UTF-8")?; + let events = frame_events::journal(&["--receive", source], &[]).await; + drop(holder.stdin.take()); + Ok((events, holder.wait()?)) +} diff --git a/test-support/windows-oplock/lock.ps1 b/test-support/windows-oplock/lock.ps1 new file mode 100644 index 0000000..7181029 --- /dev/null +++ b/test-support/windows-oplock/lock.ps1 @@ -0,0 +1,11 @@ +param([string]$Source) +# Holds an exclusive byte-range lock over $Source, so another process can open +# the file but its first read fails with ERROR_LOCK_VIOLATION. Windows has no +# EISDIR; this is its "opens, then cannot be read" source. [LSP-PULL-TRANSPORT] +$ErrorActionPreference='Stop' +$stream=[IO.File]::Open($Source,'Open','ReadWrite','ReadWrite') +try { + $stream.Lock(0,[Math]::Max(1,$stream.Length)) + Write-Output '{"state":"locked"}' + $null=[Console]::In.ReadLine() +} finally { $stream.Dispose() } From 1f22545715729fd41731d8ea74d6a2eb6b2f8133 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:44:38 +1100 Subject: [PATCH 31/39] Evidence: the Windows section for #49, #52, #42 and the Windows-only CI regressions Co-Authored-By: Claude Opus 5.5 --- docs/plans/issue-fix-evidence-21-26-48-49.md | 68 +++++++++++++++++++- 1 file changed, 67 insertions(+), 1 deletion(-) diff --git a/docs/plans/issue-fix-evidence-21-26-48-49.md b/docs/plans/issue-fix-evidence-21-26-48-49.md index 588107a..7b27ad7 100644 --- a/docs/plans/issue-fix-evidence-21-26-48-49.md +++ b/docs/plans/issue-fix-evidence-21-26-48-49.md @@ -13,7 +13,7 @@ export LSPKIT_REFERENCE_BIN=$PWD/target/debug/examples/diagnostic-reference |---|---|---|---| | #21 truncated frame read as clean EOF | `5590a52` (PR #27, added `next_frame` in `crates/lspkit-sidecar/src/inbound.rs`, now `crates/lspkit/src/sidecar/inbound.rs:109`) | v0.1.0 onward, including 0.5.0 | `crates/lspkit/tests/sidecar_disconnect_session.rs:79` `native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic` | | #26 cancellation test drops the earlier partial | `741e806` (PR #33, `crates/lspkit-server/tests/cli_sessions/dispatcher.rs:90`) | v0.1.0 onward, including 0.5.0 | `crates/lspkit-server/tests/cli_sessions/dispatcher.rs:119` `cancel_during_a_scan_stops_the_stream_with_the_standard_error` | -| #49 URI host read as a path folder; UNC and `\\?\` paths | `384b341` (PR #50) | not yet; ships in v0.6.0 | `crates/lspkit-server/tests/uri_authority.rs` `localhost_authority_is_the_host_not_a_folder`; Windows rows in `crates/lspkit-server/src/uri_style_tests.rs:46` and `:57` | +| #49 URI host read as a path folder; UNC and `\\?\` paths | `384b341` (PR #50) | not yet; ships in v0.6.0 | `crates/lspkit-server/tests/uri_authority.rs` `localhost_authority_is_the_host_not_a_folder`; the Windows plan's table in `crates/lspkit-server/src/uri_cases.rs`, run by `src/uri_style_tests.rs` (every OS) and `tests/uri_windows.rs` (Windows, public API); see [Windows](#windows) | | #48 no server→client requests | this branch | ships in v0.6.0 | `crates/lspkit-server/tests/outbound.rs:84` and `:183`, `crates/lspkit-server/tests/outbound_heap_leak.rs:66`, `crates/lspkit/tests/sidecar_correlator.rs:211` | ## #21: a truncated frame is an error, not a clean end of stream @@ -297,3 +297,69 @@ post-query retire removed → a close during a pull freed 160 of its 6553 ``` `set_open(..).to(false)` removed → `forgetting_one_document_keeps_every_other_memo_warm` fails with "a close never runs the compiler: left 4, right 3" (SharpLsp1's mutant, now killed). + +## Windows + +Captured natively on Microsoft Windows 11 Enterprise (NT 10.0.26300, AMD64), Rust 1.100.0 `x86_64-pc-windows-msvc`, .NET SDK 10. On this build, `cfg(windows)` selects the real Windows code paths. Linux rows were checked in WSL (`UbuntuDev`) and by CI. + +### #49: the issue's Windows verification plan + +The plan's tables live once, in `crates/lspkit-server/src/uri_cases.rs`: 35 round trips, 14 paths → URIs, 9 rejected paths and 23 rejected URIs. Two suites run them: + +- `src/uri_style_tests.rs` runs them through `Style::Windows`, on every OS. +- `tests/uri_windows.rs` (`#![cfg(windows)]`) runs them through the public `uri_to_path` and `path_to_uri` only, so it also compiles against the pre-fix crate. It adds real-filesystem rows: + - `std::fs::canonicalize` output for a temp file, a temp dir, a dir with spaces, Unicode and reserved-character names; + - a file under a path longer than 300 characters, created through `\\?\`; + - files named `trailing dot.`, `trailing space `, `aux.rs`, `NUL`, `CON` and `com1.txt`, and a file inside a `CON` folder, each read back with its contents through the decoded path; + - a `mklink /J` junction; + - `C:\PROGRA~1`; + - drive-letter case. + +```sh +git show 384b341~1:crates/lspkit-server/src/uri.rs > crates/lspkit-server/src/uri.rs # or 384b341 for PR #50 +cargo nextest run -p lspkit-server --test uri_windows +git checkout crates/lspkit-server/src/uri.rs +``` + +Failing rows, out of the table size: + +| `uri.rs` | `uri_windows` tests | Round trips | Paths → URIs | Rejected paths accepted | Rejected URIs accepted | +|---|---|---|---|---|---| +| pre-fix `384b341~1` | 0 / 10 | 22 / 34 | 12 / 14 | 4 / 9 | 15 / 20 | +| PR #50 `384b341` | 4 / 10 | 12 / 34 | 4 / 14 | 4 / 9 | 8 / 20 | +| `7f37353` and later | 10 / 10 | 0 / 35 | 0 / 14 | 0 / 9 | 0 / 23 | + +The per-row tallies were taken before the `%252F` round trip and the encoded-host rejections joined the tables. + +The PR #50 rows that failed on Windows: + +- `file://%3F/C:/a.rs` decoded to the verbatim path `\\?\C:\a.rs`, and `file://./C:/a.rs` to the device path `\\.\C:\a.rs`. +- `\\.\pipe\name`, `\\?\Volume{…}` and `\\?\GLOBALROOT\…` encoded to URIs. +- `%2F` and `%5C` inside a name became real separators. +- A URI with a port or userinfo decoded to a UNC server name. +- A lower-case drive letter or server name gave one file a second URI. +- A real file named `trailing dot.` decoded to a path Win32 opens as `trailing dot` (NotFound). +- A real file named `NUL` decoded to a path that opens the NUL device on Windows 11. + +The full row-by-row output is on #49 (comment 6959676768). + +Two more Windows-only failures came out of the same work: + +- `tests/uri_authority.rs` did not compile on Windows (`-D unused-imports` once its only test was gated off). +- `tests/uri.rs` `truncated_percent_encoding_passes_through_bytes` failed there, because `/tmp/a%` has no drive. + +### #52 on Windows + +`pull_forget` 6/6 and `pull_forget_heap` 1/1 pass. `forget_frees_the_closed_documents_diagnostics_before_it_returns` holds a `Weak` to the forgotten report and was red on `d2a22c4`: `left: 1, right: 0`, because the memo stayed alive until a later pull and then until Salsa's next revision. It goes red again if either the immediate apply or the tombstone revision write is removed. `an_empty_uri_is_analyzed_never_mistaken_for_a_forgotten_slot` was red on `d2a22c4` with `left: [] right: [""]`. + +### Windows-only regressions found by running CI's steps here + +| Step | Failure on Windows | Fix | +|---|---|---| +| `make lint` | `clippy::doc_markdown` in a `cfg(windows)` doc comment in `lsp-profiler-dotnet/src/process.rs`. Linux never compiles it. | `13c6f82` | +| `make website-test` | `FileNotFoundError` from `subprocess.run(["npm", …])`: `CreateProcess` cannot find `npm.cmd` by its bare name. Pages were also read in the Windows code page. | `13c6f82` | +| `make test` | `clock::tests::century_leap_rules_hold_before_the_epoch` panicked with "overflow when subtracting duration from `SystemTime`". Windows `SystemTime` starts at 1601, so the 1600-02-29 row cannot be a `SystemTime` there, and fail-fast stopped the run. | `0dc2f04` | + +### #42 on Windows + +`sh scripts/release-assets.sh 0.0.0-test win-x64 linux-x64` produces both engine archives and the consumer kit. The kit holds no `bin/` or `obj/` output. With `LSP_PROFILER_DOTNET_ENGINE` pointing at the extracted `win-x64` `lsp-profiler-dotnet-engine.exe`, `cargo nextest run -p lsp-profiler-dotnet --all-features` passes 47 of 48, every .NET e2e session included. The one failure is `engine::tests::a_missing_engine_names_every_place_it_looked`, which checks the message for an absent engine and so needs the variable unset; it passes in `make test`. From c35f6a73e9fac0f3f01f4e54b735304c22655a1b Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:47:59 +1100 Subject: [PATCH 32/39] Profiler UI changelog: drop the non-profiler [REL-CONSUMER-ASSETS] citation the profiler spec gate rejects --- packages/lsp-profiler-ui/CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/lsp-profiler-ui/CHANGELOG.md b/packages/lsp-profiler-ui/CHANGELOG.md index a6191ca..b546741 100644 --- a/packages/lsp-profiler-ui/CHANGELOG.md +++ b/packages/lsp-profiler-ui/CHANGELOG.md @@ -2,7 +2,7 @@ ## Unreleased -- The profiler's .NET engine, fixtures, specs and test-support ship as GitHub Release assets (`lsp-profiler-dotnet-engine--.tar.gz`, `lspkit-consumer-kit-.tar.gz`), so consumers no longer need a source checkout. [REL-CONSUMER-ASSETS] +- The profiler's .NET engine, fixtures, specs and test-support ship as GitHub Release assets (`lsp-profiler-dotnet-engine--.tar.gz`, `lspkit-consumer-kit-.tar.gz`), so consumers no longer need a source checkout. ## 0.4.0 From 2154ff5d07709f1ebc99c8afb33fb618c8ccf412 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:49:37 +1100 Subject: [PATCH 33/39] Pin the .NET SDK to 10.0.404 in global.json; CI and release install exactly that SDK --- .github/workflows/ci.yml | 4 ++-- .github/workflows/release.yml | 4 ++-- global.json | 6 ++++++ 3 files changed, 10 insertions(+), 4 deletions(-) create mode 100644 global.json diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8692693..dd64cd9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -39,10 +39,10 @@ jobs: components: rustfmt, clippy, llvm-tools-preview # The profiler's .NET engine and the fixture its e2e tests profile build in - # `make test` (net8.0, rolled forward to this SDK's runtime). [PROF-TESTING] + # `make test` (net8.0, rolled forward to the SDK pinned in global.json). [PROF-TESTING] - uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: - dotnet-version: "10.0.x" + global-json-file: global.json # crates/lsp-profiler/build.rs generates the wire model from # docs/models/profiler.td with typeDiagram. [PROF-WIRE-GEN] diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d903acb..3d7c2c2 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -65,10 +65,10 @@ jobs: run: npm install -g npm@11.21.1 typediagram@0.11.0 # Builds the .NET profiler engine release assets (net8.0, rolled - # forward to this SDK's runtime). [REL-CONSUMER-ASSETS] + # forward to the SDK pinned in global.json). [REL-CONSUMER-ASSETS] - uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: - dotnet-version: "10.0.x" + global-json-file: global.json - name: Install version stamper and vuln gate uses: taiki-e/install-action@5488ac5a951645ce95062214902ac4b6bc1a1037 # v2.87.32 diff --git a/global.json b/global.json new file mode 100644 index 0000000..89ddff2 --- /dev/null +++ b/global.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "10.0.404", + "rollForward": "disable" + } +} From faec6699379225de4dff28d019229033a6c7d67a Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:51:40 +1100 Subject: [PATCH 34/39] run-cli: quote arguments for cmd.exe, so the Windows npm shim gets them intact On Windows every capture ran through cmd.exe (shell: true), which joins the command and its arguments unquoted. A quote or a space in any of them was lost or split. The generator passes an absolute model path, so a checkout under a folder with spaces broke wire generation, and run-cli.test.mjs failed on Windows (`ab is not defined`). Only a bare name or a .cmd/.bat shim goes through the shell now, with the command and every argument quoted the way the Windows C runtime parses them back. A real .exe runs directly. New tests: a .cmd shim whose path has a space receives spaces, embedded quotes and a trailing backslash intact, and quoteForCmd's escaping is pinned. Co-Authored-By: Claude Opus 5.5 --- scripts/typediagram/run-cli.mjs | 20 ++++++++++++++++--- scripts/typediagram/run-cli.test.mjs | 30 +++++++++++++++++++++++++++- 2 files changed, 46 insertions(+), 4 deletions(-) diff --git a/scripts/typediagram/run-cli.mjs b/scripts/typediagram/run-cli.mjs index f81b5e1..01311d9 100644 --- a/scripts/typediagram/run-cli.mjs +++ b/scripts/typediagram/run-cli.mjs @@ -28,13 +28,27 @@ export function captureStdout(command, args) { function runInto(command, args, file) { const stdout = openSync(file, "w"); + // On Windows the npm shim is a `.cmd`, which only resolves through cmd.exe. + // A shell joins arguments into one command line unquoted, so each argument + // is quoted for it; a real executable runs directly, with Node's own quoting. + const shell = process.platform === "win32" && !/\.(exe|com)$/i.test(command); try { - // On Windows the npm shim is a `.cmd`, which only resolves through a shell. - execFileSync(command, args, { + const [program, argv] = shell ? [quoteForCmd(command), args.map(quoteForCmd)] : [command, args]; + execFileSync(program, argv, { stdio: ["ignore", stdout, "inherit"], - shell: process.platform === "win32", + shell, }); } finally { closeSync(stdout); } } + +/** + * One argument as the Windows C runtime parses it back from a command line: + * wrapped in quotes, with embedded quotes and the backslashes before them escaped. + * @param {string} arg + */ +export function quoteForCmd(arg) { + const escaped = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1"); + return `"${escaped}"`; +} diff --git a/scripts/typediagram/run-cli.test.mjs b/scripts/typediagram/run-cli.test.mjs index 777bb14..a8104eb 100644 --- a/scripts/typediagram/run-cli.test.mjs +++ b/scripts/typediagram/run-cli.test.mjs @@ -1,9 +1,12 @@ // Tests [PROF-WIRE-GEN]: the generator must see every byte the typeDiagram CLI // prints, or it writes a truncated wire model that no longer compiles. import assert from "node:assert/strict"; +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; import test from "node:test"; -import { captureStdout } from "./run-cli.mjs"; +import { captureStdout, quoteForCmd } from "./run-cli.mjs"; // Writes `size` bytes then exits at once, as the typeDiagram CLI does. Node // writes to a macOS pipe asynchronously, so an exit straight after the write @@ -31,3 +34,28 @@ test("a failing CLI fails the capture instead of yielding partial output", () => assert.throws(() => captureStdout(process.execPath, writeThenExit(1 << 16, 3))); assert.throws(() => captureStdout("typediagram-does-not-exist", [])); }); + +// The generator passes an absolute model path, which holds spaces when the +// checkout does. On Windows a `.cmd` shim runs through cmd.exe, which must +// hand the program back exactly the arguments it was given. +test("arguments reach a Windows .cmd shim intact", { skip: process.platform !== "win32" }, () => { + const dir = mkdtempSync(join(tmpdir(), "run-cli-shim-")); + try { + const shim = join(dir, "echo args.cmd"); + const echo = join(dir, "echo.js"); + writeFileSync(echo, "process.stdout.write(JSON.stringify(process.argv.slice(2)));"); + writeFileSync(shim, `@"${process.execPath}" "${echo}" %*\r\n`); + const args = ["--to", "rust", String.raw`C:\checkout with spaces\model.td`, 'a "quoted" word', String.raw`trailing\\`.slice(0, -1)]; + assert.deepEqual(JSON.parse(captureStdout(shim, args)), args); + } finally { + rmSync(dir, { recursive: true, force: true }); + } +}); + +test("quoting for cmd.exe escapes quotes and the backslashes before them", () => { + assert.equal(quoteForCmd("plain"), '"plain"'); + assert.equal(quoteForCmd("two words"), '"two words"'); + assert.equal(quoteForCmd('say "hi"'), '"say \\"hi\\""'); + assert.equal(quoteForCmd('a\\"b'), '"a\\\\\\"b"'); + assert.equal(quoteForCmd("dir\\"), '"dir\\\\"'); +}); From 5b81ec38c457a6cb99da38acda331d099ab2e641 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:51:41 +1100 Subject: [PATCH 35/39] Tests: no unwrap, expect, unwrap_or, map_or or panic in the URI, forget and sidecar tests Every failure is an assertion on the whole result instead, for example assert_eq!(uri_to_path(u).ok(), Some(path)) or assert!(matches!(r, Err(UriError::..))). A test that needs the value asserts first and binds it with let-else. No check was weakened. Several are stricter: round trips compare exact URIs where they checked only substrings. Covers src/uri_style_tests.rs, tests/uri.rs, tests/uri_authority.rs, tests/pull_forget.rs, pull.rs's memory test and lspkit/tests/sidecar_disconnect_session.rs. Co-Authored-By: Claude Opus 5.5 --- crates/lspkit-server/src/pull.rs | 15 +- crates/lspkit-server/src/uri_style_tests.rs | 58 +++-- crates/lspkit-server/tests/pull_forget.rs | 31 +-- crates/lspkit-server/tests/uri.rs | 214 ++++++++++-------- crates/lspkit-server/tests/uri_authority.rs | 19 +- .../tests/sidecar_disconnect_session.rs | 63 ++++-- 6 files changed, 244 insertions(+), 156 deletions(-) diff --git a/crates/lspkit-server/src/pull.rs b/crates/lspkit-server/src/pull.rs index 0892b9b..8d09afe 100644 --- a/crates/lspkit-server/src/pull.rs +++ b/crates/lspkit-server/src/pull.rs @@ -473,12 +473,17 @@ mod memory_tests { #[test] fn cleared_database_cannot_publish_under_the_replacement_revision() { let store = PullStore::new(Arc::new(|_| Ok(Arc::new(Vec::new())))); - let _report = store - .diagnostics("file:///closed.json", 1) - .expect("populate Salsa input"); - let queued = Arc::clone(&store.query.lock().expect("database owner")); + let populated = store.diagnostics("file:///closed.json", 1); + assert!(populated.is_ok(), "populate Salsa input: {populated:?}"); + let owner = store.query.lock(); + assert!(owner.is_ok(), "database owner lock"); + let Ok(owner) = owner else { + return; + }; + let queued = Arc::clone(&*owner); + drop(owner); let allocation = Arc::downgrade(&queued); - store.clear().expect("discard closed inputs"); + assert_eq!(store.clear(), Ok(()), "discard closed inputs"); assert_eq!(store.query_revision(&queued), Err(PullError::Superseded)); drop(queued); assert_eq!( diff --git a/crates/lspkit-server/src/uri_style_tests.rs b/crates/lspkit-server/src/uri_style_tests.rs index 8ed5de1..0af9edd 100644 --- a/crates/lspkit-server/src/uri_style_tests.rs +++ b/crates/lspkit-server/src/uri_style_tests.rs @@ -10,15 +10,21 @@ mod cases; #[test] fn windows_uris_decode_to_exact_paths_and_round_trip() { for (uri, path, canonical) in cases::ROUND_TRIPS { - let decoded = uri_to_native(uri, Style::Windows).expect("a Windows URI decodes"); - assert_eq!(decoded, path, "{uri}"); assert_eq!( - native_to_uri(&decoded, Style::Windows).as_deref(), + uri_to_native(uri, Style::Windows).ok().as_deref(), + Some(path), + "{uri}" + ); + assert_eq!( + native_to_uri(path, Style::Windows).as_deref(), Some(canonical), "{path}" ); - let again = uri_to_native(canonical, Style::Windows).expect("re-decodes"); - assert_eq!(again, path, "{canonical} round-trips"); + assert_eq!( + uri_to_native(canonical, Style::Windows).ok().as_deref(), + Some(path), + "{canonical} round-trips" + ); } } @@ -30,10 +36,10 @@ fn windows_paths_encode_to_one_canonical_uri() { Some(uri), "{path}" ); - let decoded = uri_to_native(uri, Style::Windows).expect("decodes"); + let decoded = uri_to_native(uri, Style::Windows); assert!( - !decoded.contains('/'), - "{uri} decodes with native separators" + decoded.as_ref().is_ok_and(|native| !native.contains('/')), + "{uri} decodes with native separators: {decoded:?}" ); } } @@ -48,10 +54,15 @@ fn windows_device_and_rootless_paths_have_no_uri() { #[test] fn windows_uris_without_an_absolute_path_are_rejected() { for (uri, variant) in cases::URIS_REJECTED { - let err = uri_to_native(uri, Style::Windows).expect_err("no absolute path"); - assert!(format!("{err:?}").starts_with(variant), "{uri}: {err:?}"); - if let UriError::NoLocalPath(rejected) = &err { - assert_eq!(rejected, uri, "the error names the URI"); + let rejected = uri_to_native(uri, Style::Windows); + assert!( + rejected + .as_ref() + .is_err_and(|err| format!("{err:?}").starts_with(variant)), + "{uri} must be {variant}: {rejected:?}" + ); + if let Err(UriError::NoLocalPath(named)) = &rejected { + assert_eq!(named, uri, "the error names the URI"); } } } @@ -68,8 +79,8 @@ const UNIX_ROUND_TRIPS: [(&str, &str); 3] = [ fn both_styles_share_one_authority_parser() { for (uri, path) in UNIX_ROUND_TRIPS { assert_eq!( - uri_to_native(uri, Style::Unix).expect("local"), - path, + uri_to_native(uri, Style::Unix).ok().as_deref(), + Some(path), "{uri}" ); } @@ -78,18 +89,21 @@ fn both_styles_share_one_authority_parser() { Some("file:///tmp/a%20b.rs") ); for style in [Style::Unix, Style::Windows] { - let remote = uri_to_native("file://server/", style).expect_err("no share path"); - assert!(matches!(remote, UriError::NoLocalPath(_)), "{style:?}"); - let scheme = uri_to_native("https://server/a.rs", style).expect_err("not file"); + let remote = uri_to_native("file://server/", style); + assert!(matches!(remote, Err(UriError::NoLocalPath(_))), "{style:?}"); + let scheme = uri_to_native("https://server/a.rs", style); + assert!( + matches!(scheme, Err(UriError::UnsupportedScheme(_))), + "{style:?}" + ); + let encoded = uri_to_native("file:///C:/a%2Fb", style); assert!( - matches!(scheme, UriError::UnsupportedScheme(_)), + matches!(encoded, Err(UriError::NoLocalPath(_))), "{style:?}" ); - let encoded = uri_to_native("file:///C:/a%2Fb", style).expect_err("an encoded /"); - assert!(matches!(encoded, UriError::NoLocalPath(_)), "{style:?}"); - let truncated = uri_to_native("file:///C:/a%", style).expect_err("a lone %"); + let truncated = uri_to_native("file:///C:/a%", style); assert!( - matches!(truncated, UriError::InvalidUtf8(None)), + matches!(truncated, Err(UriError::InvalidUtf8(None))), "{style:?}" ); } diff --git a/crates/lspkit-server/tests/pull_forget.rs b/crates/lspkit-server/tests/pull_forget.rs index 046fb84..3206059 100644 --- a/crates/lspkit-server/tests/pull_forget.rs +++ b/crates/lspkit-server/tests/pull_forget.rs @@ -79,7 +79,7 @@ fn forgetting_one_document_keeps_every_other_memo_warm() { } let revision = store.revision(); let before = total_calls(&calls); - store.forget(A).expect("forget a closed document"); + assert_eq!(store.forget(A), Ok(()), "forget a closed document"); assert_eq!(store.revision(), revision, "forgetting supersedes nothing"); assert_eq!( total_calls(&calls), @@ -103,11 +103,13 @@ fn forget_is_idempotent_and_a_recycled_input_never_replays_old_truth() { for uri in [A, B, C] { let _first = pull(&store, uri); } - store - .forget("file:///never/opened.cs") - .expect("an unknown URI"); - store.forget(B).expect("first forget"); - store.forget(B).expect("a repeated forget"); + assert_eq!( + store.forget("file:///never/opened.cs"), + Ok(()), + "an unknown URI" + ); + assert_eq!(store.forget(B), Ok(()), "first forget"); + assert_eq!(store.forget(B), Ok(()), "a repeated forget"); let _fresh = pull(&store, D); assert_eq!( calls_for(&calls, D), @@ -120,7 +122,7 @@ fn forget_is_idempotent_and_a_recycled_input_never_replays_old_truth() { let _warm = pull(&store, uri); assert_eq!(calls_for(&calls, uri), 1, "{uri} never recomputed"); } - store.clear().expect("clear still drops everything"); + assert_eq!(store.clear(), Ok(()), "clear still drops everything"); let _cold = pull(&store, C); assert_eq!(calls_for(&calls, C), 2, "clear recomputes every document"); } @@ -135,17 +137,20 @@ fn forget_frees_the_closed_documents_diagnostics_before_it_returns() { }; let (a, b) = (held(A), held(B)); let strong = |weak: &Option>>| { - weak.as_ref() - .map_or(usize::MAX, std::sync::Weak::strong_count) + weak.as_ref().map(std::sync::Weak::strong_count) }; - assert_eq!((strong(&a), strong(&b)), (1, 1), "only the memos hold them"); - store.forget(A).expect("forget A"); + assert_eq!( + (strong(&a), strong(&b)), + (Some(1), Some(1)), + "only the memos hold them" + ); + assert_eq!(store.forget(A), Ok(()), "forget A"); assert_eq!( strong(&a), - 0, + Some(0), "A's diagnostics are freed with no later pull" ); - assert_eq!(strong(&b), 1, "B's memo is untouched"); + assert_eq!(strong(&b), Some(1), "B's memo is untouched"); } #[test] diff --git a/crates/lspkit-server/tests/uri.rs b/crates/lspkit-server/tests/uri.rs index 2f47943..735afa2 100644 --- a/crates/lspkit-server/tests/uri.rs +++ b/crates/lspkit-server/tests/uri.rs @@ -1,83 +1,78 @@ //! End-to-end tests for [`lspkit_server::uri`] conversions. +use std::path::Path; +#[cfg(not(windows))] use std::path::PathBuf; use lspkit_server::{path_to_uri, uri_to_path, UriError}; +/// `path` encodes to exactly `uri`, which decodes back to exactly `path`. +#[cfg(not(windows))] +fn assert_round_trip(path: &Path, uri: &str) { + assert_eq!( + path_to_uri(path).ok().as_deref(), + Some(uri), + "{}", + path.display() + ); + assert_eq!(uri_to_path(uri).ok().as_deref(), Some(path), "{uri}"); +} + #[cfg(not(windows))] #[test] fn round_trip_simple_unix_path() { - let path = PathBuf::from("/tmp/foo.txt"); - let uri = path_to_uri(&path).expect("encoded"); - assert_eq!(uri, "file:///tmp/foo.txt"); - let decoded = uri_to_path(&uri).expect("decoded"); - assert_eq!(decoded, path); + assert_round_trip(Path::new("/tmp/foo.txt"), "file:///tmp/foo.txt"); } #[cfg(not(windows))] #[test] fn round_trip_path_with_spaces() { - let path = PathBuf::from("/tmp/my project/foo bar.txt"); - let uri = path_to_uri(&path).expect("encoded"); - assert!(uri.contains("%20")); - let decoded = uri_to_path(&uri).expect("decoded"); - assert_eq!(decoded, path); + assert_round_trip( + Path::new("/tmp/my project/foo bar.txt"), + "file:///tmp/my%20project/foo%20bar.txt", + ); } #[cfg(not(windows))] #[test] fn round_trip_path_with_unicode() { - let path = PathBuf::from("/tmp/caf\u{00e9}/file.txt"); - let uri = path_to_uri(&path).expect("encoded"); - let decoded = uri_to_path(&uri).expect("decoded"); - assert_eq!(decoded, path); + assert_round_trip( + Path::new("/tmp/caf\u{00e9}/file.txt"), + "file:///tmp/caf%C3%A9/file.txt", + ); } #[cfg(not(windows))] #[test] fn round_trip_path_with_hash_and_question() { - let path = PathBuf::from("/tmp/a#b?c.txt"); - let uri = path_to_uri(&path).expect("encoded"); - assert!(uri.contains("%23")); - assert!(uri.contains("%3F")); - let decoded = uri_to_path(&uri).expect("decoded"); - assert_eq!(decoded, path); + assert_round_trip(Path::new("/tmp/a#b?c.txt"), "file:///tmp/a%23b%3Fc.txt"); } #[test] fn relative_path_rejected() { - let err = path_to_uri(&PathBuf::from("relative/foo.txt")).expect_err("must reject"); - match err { - UriError::InvalidPath(p) => assert_eq!(p, PathBuf::from("relative/foo.txt")), - other => assert!( - matches!(other, UriError::InvalidPath(_)), - "wrong variant: {other:?}" - ), - } + let rejected = path_to_uri(Path::new("relative/foo.txt")); + assert!( + matches!(&rejected, Err(UriError::InvalidPath(p)) if p == Path::new("relative/foo.txt")), + "{rejected:?}" + ); } #[test] fn non_file_scheme_rejected() { - let err = uri_to_path("https://example.com/foo").expect_err("must reject"); - match err { - UriError::UnsupportedScheme(s) => assert_eq!(s, "https://example.com/foo"), - other => assert!( - matches!(other, UriError::UnsupportedScheme(_)), - "wrong variant: {other:?}" - ), - } + let rejected = uri_to_path("https://example.com/foo"); + assert!( + matches!(&rejected, Err(UriError::UnsupportedScheme(s)) if s == "https://example.com/foo"), + "{rejected:?}" + ); } #[test] fn invalid_percent_encoding_rejected() { - let err = uri_to_path("file:///tmp/%ZZbroken").expect_err("must reject"); - match err { - UriError::InvalidUtf8(_) => {} - other => assert!( - matches!(other, UriError::InvalidUtf8(_)), - "wrong variant: {other:?}" - ), - } + let rejected = uri_to_path("file:///tmp/%ZZbroken"); + assert!( + matches!(rejected, Err(UriError::InvalidUtf8(_))), + "{rejected:?}" + ); } /// [URI-WINDOWS] A `%` not followed by two hex digits is malformed on every @@ -85,23 +80,30 @@ fn invalid_percent_encoding_rejected() { #[test] fn truncated_percent_encoding_rejected() { for uri in ["file:///tmp/a%", "file:///tmp/a%2"] { - let err = uri_to_path(uri).expect_err("must reject"); - assert!(matches!(err, UriError::InvalidUtf8(None)), "{uri}: {err:?}"); + let rejected = uri_to_path(uri); + assert!( + matches!(rejected, Err(UriError::InvalidUtf8(None))), + "{uri}: {rejected:?}" + ); } } #[cfg(not(windows))] #[test] fn lowercase_hex_percent_decodes() { - let decoded = uri_to_path("file:///tmp/a%2cb%c3%a9").expect("decoded"); - assert_eq!(decoded, PathBuf::from("/tmp/a,b\u{e9}")); + assert_eq!( + uri_to_path("file:///tmp/a%2cb%c3%a9").ok(), + Some(PathBuf::from("/tmp/a,b\u{e9}")) + ); } #[cfg(not(windows))] #[test] fn uppercase_hex_percent_decodes() { - let decoded = uri_to_path("file:///tmp/a%2Cb%C3%A9").expect("decoded"); - assert_eq!(decoded, PathBuf::from("/tmp/a,b\u{e9}")); + assert_eq!( + uri_to_path("file:///tmp/a%2Cb%C3%A9").ok(), + Some(PathBuf::from("/tmp/a,b\u{e9}")) + ); } /// [URI-WINDOWS] An encoded `/` stays inside its file name, which no Unix @@ -110,49 +112,59 @@ fn uppercase_hex_percent_decodes() { #[test] fn encoded_separator_is_rejected_never_split_on() { for uri in ["file:///tmp/a%2fb", "file:///tmp/a%2Fb"] { - let err = uri_to_path(uri).expect_err("an encoded separator"); + let rejected = uri_to_path(uri); assert!( - matches!(&err, UriError::NoLocalPath(rejected) if rejected == uri), - "{uri}: {err:?}" + matches!(&rejected, Err(UriError::NoLocalPath(named)) if named == uri), + "{uri}: {rejected:?}" ); } - let backslash = uri_to_path("file:///tmp/a%5Cb").expect("a Unix name may hold a backslash"); - assert_eq!(backslash, PathBuf::from(r"/tmp/a\b")); - let literal = uri_to_path("file:///tmp/a%252Fb").expect("an encoded percent"); assert_eq!( - literal, - PathBuf::from("/tmp/a%2Fb"), + uri_to_path("file:///tmp/a%5Cb").ok(), + Some(PathBuf::from(r"/tmp/a\b")), + "a Unix name may hold a backslash" + ); + assert_eq!( + uri_to_path("file:///tmp/a%252Fb").ok(), + Some(PathBuf::from("/tmp/a%2Fb")), "decoded once, never twice" ); - let host = uri_to_path("file://host%2Fshare/a.rs").expect_err("an encoded / in the host"); - assert!(matches!(host, UriError::NoLocalPath(_)), "{host:?}"); + let host = uri_to_path("file://host%2Fshare/a.rs"); + assert!( + matches!(host, Err(UriError::NoLocalPath(_))), + "an encoded / in the host: {host:?}" + ); } #[test] fn invalid_utf8_after_decode_rejected() { // %FF %FE are not valid UTF-8. - let err = uri_to_path("file:///tmp/%FF%FE").expect_err("must reject"); - match err { - UriError::InvalidUtf8(_) => {} - other => assert!( - matches!(other, UriError::InvalidUtf8(_)), - "wrong variant: {other:?}" - ), - } + let rejected = uri_to_path("file:///tmp/%FF%FE"); + assert!( + matches!(rejected, Err(UriError::InvalidUtf8(_))), + "{rejected:?}" + ); } #[test] fn error_display_lists_offending_input() { - let err = uri_to_path("ftp://x").expect_err("must reject"); - let rendered = format!("{err}"); - assert!(rendered.contains("ftp://x")); + let rejected = uri_to_path("ftp://x"); + assert!( + rejected + .as_ref() + .is_err_and(|err| err.to_string().contains("ftp://x")), + "{rejected:?}" + ); } #[test] fn error_debug_works() { - let err = path_to_uri(&PathBuf::from("rel")).expect_err("must reject"); - let rendered = format!("{err:?}"); - assert!(rendered.contains("InvalidPath")); + let rejected = path_to_uri(Path::new("rel")); + assert!( + rejected + .as_ref() + .is_err_and(|err| format!("{err:?}").contains("InvalidPath")), + "{rejected:?}" + ); } /// [URI-AUTHORITY] A URI's host is its authority, never the first path segment. @@ -165,35 +177,54 @@ fn uri_authority_is_parsed_not_read_as_a_path_segment() { "file:///tmp/a.rs", ]; for uri in local_forms { - let decoded = uri_to_path(uri).expect("a local URI decodes"); - assert_eq!(decoded, PathBuf::from("/tmp/a.rs"), "{uri}"); + let decoded = uri_to_path(uri); + assert_eq!( + decoded.as_deref().ok(), + Some(Path::new("/tmp/a.rs")), + "{uri}" + ); assert!( - decoded.is_absolute(), + decoded.as_ref().is_ok_and(|path| path.is_absolute()), "{uri} must decode to an absolute path" ); assert_eq!( - path_to_uri(&decoded).expect("encoded"), - "file:///tmp/a.rs", + decoded + .as_deref() + .ok() + .and_then(|path| path_to_uri(path).ok()) + .as_deref(), + Some("file:///tmp/a.rs"), "{uri} re-encodes without its host" ); } for uri in ["file://", "file://localhost"] { - let decoded = uri_to_path(uri).expect("a URI with no path names the root"); - assert_eq!(decoded, PathBuf::from("/"), "{uri}"); + assert_eq!( + uri_to_path(uri).ok(), + Some(PathBuf::from("/")), + "{uri} names the root" + ); } - let err = uri_to_path("file://%ZZhost/a.rs").expect_err("a malformed host"); - assert!(matches!(err, UriError::InvalidUtf8(None)), "{err:?}"); + let host = uri_to_path("file://%ZZhost/a.rs"); + assert!( + matches!(host, Err(UriError::InvalidUtf8(None))), + "a malformed host: {host:?}" + ); for uri in [ "file://server/share/a.rs", "file://wsl.localhost/Ubuntu/a.rs", "file://server", ] { - let err = uri_to_path(uri).expect_err("a remote host has no local path here"); + let rejected = uri_to_path(uri); + assert!( + matches!(&rejected, Err(UriError::NoLocalPath(named)) if named == uri), + "{uri}: {rejected:?}" + ); assert!( - matches!(&err, UriError::NoLocalPath(rejected) if rejected == uri), - "{uri}: {err:?}" + rejected + .as_ref() + .is_err_and(|err| err.to_string().contains(uri)), + "the error names {uri}" ); - assert!(format!("{err}").contains(uri), "the error names {uri}"); } } @@ -203,16 +234,15 @@ fn uri_authority_is_parsed_not_read_as_a_path_segment() { fn non_utf8_path_rejected() { use std::{ffi::OsStr, os::unix::ffi::OsStrExt}; let path = PathBuf::from("/tmp").join(OsStr::from_bytes(&[0x66, 0xFF, 0x6F])); - let err = path_to_uri(&path).expect_err("must reject"); + let rejected = path_to_uri(&path); assert!( - matches!(&err, UriError::InvalidPath(rejected) if *rejected == path), - "{err:?}" + matches!(&rejected, Err(UriError::InvalidPath(named)) if *named == path), + "{rejected:?}" ); } #[cfg(not(windows))] #[test] fn empty_path_after_scheme_decodes_to_root() { - let decoded = uri_to_path("file:///").expect("decoded"); - assert_eq!(decoded, PathBuf::from("/")); + assert_eq!(uri_to_path("file:///").ok(), Some(PathBuf::from("/"))); } diff --git a/crates/lspkit-server/tests/uri_authority.rs b/crates/lspkit-server/tests/uri_authority.rs index 89a756d..76c1b52 100644 --- a/crates/lspkit-server/tests/uri_authority.rs +++ b/crates/lspkit-server/tests/uri_authority.rs @@ -3,7 +3,7 @@ //! Unix-only: the Windows rows live in `uri_windows.rs`. #![cfg(not(windows))] -use std::path::PathBuf; +use std::path::Path; use lspkit_server::{path_to_uri, uri_to_path}; @@ -15,10 +15,19 @@ fn localhost_authority_is_the_host_not_a_folder() { "file://LOCALHOST/tmp/a.rs", "file:///tmp/a.rs", ] { - let path = uri_to_path(uri).expect("a local file URI decodes"); - assert_eq!(path, PathBuf::from("/tmp/a.rs"), "{uri}"); - assert!(path.is_absolute(), "{uri} never yields a relative path"); - assert_eq!(path_to_uri(&path).expect("encodes"), "file:///tmp/a.rs"); + let path = uri_to_path(uri); + assert_eq!(path.as_deref().ok(), Some(Path::new("/tmp/a.rs")), "{uri}"); + assert!( + path.as_ref().is_ok_and(|path| path.is_absolute()), + "{uri} never yields a relative path" + ); + assert_eq!( + path.as_deref() + .ok() + .and_then(|path| path_to_uri(path).ok()) + .as_deref(), + Some("file:///tmp/a.rs") + ); } assert!( uri_to_path("file://server/share/a.rs").is_err(), diff --git a/crates/lspkit/tests/sidecar_disconnect_session.rs b/crates/lspkit/tests/sidecar_disconnect_session.rs index 95d71df..dcf04fc 100644 --- a/crates/lspkit/tests/sidecar_disconnect_session.rs +++ b/crates/lspkit/tests/sidecar_disconnect_session.rs @@ -39,6 +39,12 @@ async fn produced_frame() -> TestResult<(Vec, Value)> { Ok((output.stdout, expected)) } +/// `result`'s value, or a failed assertion naming `what` and the error. +fn ok(result: Result, what: &str) -> Option { + assert!(result.is_ok(), "{what}: {:?}", result.as_ref().err()); + result.ok() +} + /// A corrupt native stream produces one visible error, then releases both streams. fn assert_failure(events: &[Value]) { let failures: Vec<_> = events @@ -46,8 +52,13 @@ fn assert_failure(events: &[Value]) { .filter(|event| at(event, "/kind") == "error") .collect(); assert_eq!(failures.len(), 1, "one terminal native read error"); - let failure = failures.first().copied().unwrap_or(&Value::Null); - assert_ne!(at(failure, "/message").as_str().unwrap_or_default(), ""); + let message = failures + .first() + .and_then(|failure| at(failure, "/message").as_str()); + assert!( + message.is_some_and(|text| !text.is_empty()), + "the error names its cause: {message:?}" + ); frame_events::assert_closed(events, None); } @@ -79,23 +90,30 @@ fn assert_valid_then_truncated(events: &[Value], expected: &Value) { async fn native_disconnects_preserve_prefix_and_payload_failures_after_valid_traffic() { let empty = frame_events::output(&["--backend"], &[]).await.stdout; assert!(empty.is_empty(), "real backend EOF has no synthetic reply"); - let clean = received(&empty).await.expect("receive clean native EOF"); + let Some(clean) = ok(received(&empty).await, "receive clean native EOF") else { + return; + }; assert_eq!(clean.len(), 1, "zero-byte EOF is normal"); frame_events::assert_closed(&clean, None); - let (frame, expected) = produced_frame().await.expect("produce native frame"); + let Some((frame, expected)) = ok(produced_frame().await, "produce native frame") else { + return; + }; assert!(frame.len() > 5, "actual backend emitted a complete frame"); - let prefix = received(frame.get(..2).unwrap_or_default()) - .await - .expect("receive torn prefix"); + let (Some(torn_prefix), Some(torn_body)) = (frame.get(..2), frame.get(..5)) else { + return; + }; + let Some(prefix) = ok(received(torn_prefix).await, "receive torn prefix") else { + return; + }; assert_truncation(&prefix); - let body = received(frame.get(..5).unwrap_or_default()) - .await - .expect("receive torn body"); + let Some(body) = ok(received(torn_body).await, "receive torn body") else { + return; + }; assert_truncation(&body); - let bytes = [frame.as_slice(), frame.get(..5).unwrap_or_default()].concat(); - let events = received(&bytes) - .await - .expect("receive valid then torn frames"); + let bytes = [frame.as_slice(), torn_body].concat(); + let Some(events) = ok(received(&bytes).await, "receive valid then torn frames") else { + return; + }; assert_valid_then_truncated(&events, &expected); } @@ -103,8 +121,14 @@ async fn native_disconnects_preserve_prefix_and_payload_failures_after_valid_tra #[cfg(unix)] #[tokio::test] async fn native_initial_read_failure_stays_visible() { - let directory = tempfile::TempDir::new().expect("real directory input"); - let source = directory.path().to_str().expect("UTF-8 fixture path"); + let Some(directory) = ok(tempfile::TempDir::new(), "real directory input") else { + return; + }; + let source = directory.path().to_str(); + assert!(source.is_some(), "UTF-8 fixture path"); + let Some(source) = source else { + return; + }; let events = frame_events::journal(&["--receive", source], &[]).await; assert_failure(&events); assert_eq!(events.len(), 2); @@ -120,9 +144,10 @@ mod owner; #[cfg(windows)] #[tokio::test] async fn native_initial_read_failure_stays_visible_on_windows() { - let (events, released) = locked_source_events() - .await - .expect("receive a locked source"); + let Some((events, released)) = ok(locked_source_events().await, "receive a locked source") + else { + return; + }; assert!(released.success(), "the lock holder exits cleanly"); assert_failure(&events); assert_eq!(events.len(), 2); From 697509045f71512b37a1c927996fd4b4c66fd5bb Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 07:53:13 +1100 Subject: [PATCH 36/39] Split civil() into year_of_era and month_day so every clock function stays under 20 lines --- crates/lsp-profiler/src/clock.rs | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/crates/lsp-profiler/src/clock.rs b/crates/lsp-profiler/src/clock.rs index c6efbfa..f49f4fc 100644 --- a/crates/lsp-profiler/src/clock.rs +++ b/crates/lsp-profiler/src/clock.rs @@ -77,13 +77,24 @@ fn civil(days: i128) -> (i128, i128, i128) { let shifted = days + EPOCH_SHIFT; let era = shifted.div_euclid(ERA_DAYS); let day_of_era = shifted - era * ERA_DAYS; - let year_of_era = (day_of_era - day_of_era.div_euclid(LEAP_CYCLE_DAYS) - + day_of_era.div_euclid(CENTURY_DAYS) - - day_of_era.div_euclid(ERA_DAYS - 1)) - .div_euclid(YEAR_DAYS); + let year_of_era = year_of_era(day_of_era); let day_of_year = day_of_era - (YEAR_DAYS * year_of_era + year_of_era.div_euclid(LEAP_YEAR_EVERY) - year_of_era.div_euclid(CENTURY_YEARS)); + let (month, day) = month_day(day_of_year); + let year = year_of_era + era * ERA_YEARS + i128::from(month < MARCH); + (year, month, day) +} + +/// The March-based year (0..=399) within its 400-year era. +fn year_of_era(day_of_era: i128) -> i128 { + (day_of_era - day_of_era.div_euclid(LEAP_CYCLE_DAYS) + day_of_era.div_euclid(CENTURY_DAYS) + - day_of_era.div_euclid(ERA_DAYS - 1)) + .div_euclid(YEAR_DAYS) +} + +/// The calendar (month, day) of a March-based day of the year. +fn month_day(day_of_year: i128) -> (i128, i128) { let (slope, offset, span) = MONTH_SLOPE; let march_month = (slope * day_of_year + offset).div_euclid(span); let day = day_of_year - (span * march_month + offset).div_euclid(slope) + 1; @@ -92,11 +103,7 @@ fn civil(days: i128) -> (i128, i128, i128) { } else { march_month + MARCH - YEAR_MONTHS }; - ( - year_of_era + era * ERA_YEARS + i128::from(month < MARCH), - month, - day, - ) + (month, day) } #[cfg(test)] From 3bc50554f83b25d9e12d06ba14e76dcfdf517901 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 08:00:24 +1100 Subject: [PATCH 37/39] Debug adapter lookup follows the requested platform: Windows PATH, Path and PATHEXT resolveAdapterPath takes a platform, but its PATH lookup used the host's node:path, so a Windows host split a POSIX request's PATH on ';' and joined with '\'. Four adapter-resolution tests failed on Windows, which was the last red step of make test there. The lookup was also wrong for real Windows requests: - a bare `netcoredbg` never matched `netcoredbg.exe`, because PATHEXT was ignored; - `env.PATH` missed the usual Windows spelling, `Path`, in a copied environment; - a request for another platform used the host separator. findOnPath(command, { env, existsSync, platform }) now owns the lookup: path.win32 or path.posix by platform, PATH and PATHEXT read case-insensitively on Windows, and PATHEXT names (default .COM;.EXE;.BAT;.CMD) for a bare command there. findExecutableOnPath keeps its public signature as a wrapper with the host's platform. New tests cover ';', Path, PATHEXT, its default, a bare name never matching without an extension, an explicit extension, and the host wrapper. 114/114 pass on Windows; the suite also passes on Linux. Co-Authored-By: Claude Opus 5.5 --- .../src/debug/adapter-resolution.ts | 67 ++++++++++++++++--- .../src/debug/test/adapter-resolution.test.ts | 65 ++++++++++++++---- 2 files changed, 111 insertions(+), 21 deletions(-) diff --git a/packages/lsp-profiler-ui/src/debug/adapter-resolution.ts b/packages/lsp-profiler-ui/src/debug/adapter-resolution.ts index 8d0186d..8d00ef8 100644 --- a/packages/lsp-profiler-ui/src/debug/adapter-resolution.ts +++ b/packages/lsp-profiler-ui/src/debug/adapter-resolution.ts @@ -48,20 +48,70 @@ function firstNonEmpty(values: readonly (string | undefined)[]): string | undefi return values.find((value) => hasText(value)); } +/** Extensions Windows runs when PATHEXT is unset. */ +const DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD"; + +/** Path rules of `platform`, never of the host running this code. */ +function pathRules(platform: NodeJS.Platform): typeof path.posix { + return platform === "win32" ? path.win32 : path.posix; +} + +/** + * The environment variable `name`. Windows variable names are case-insensitive + * (PATH is usually spelled `Path`), and a copied environment object is not. + */ +function envValue(env: NodeJS.ProcessEnv, name: string, platform: NodeJS.Platform): string { + const key = + platform === "win32" ? Object.keys(env).find((candidate) => candidate.toUpperCase() === name) : name; + const value = key === undefined ? undefined : env[key]; + return hasText(value) ? value : ""; +} + /** Split PATH into its non-empty directories. */ -function pathDirectories(env: NodeJS.ProcessEnv): string[] { - return (env.PATH ?? "").split(path.delimiter).filter((dir) => dir !== ""); +function pathDirectories(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string[] { + return envValue(env, "PATH", platform) + .split(pathRules(platform).delimiter) + .filter((dir) => dir !== ""); +} + +/** + * File names `command` can have on disk. On Windows a bare command only runs + * with one of the PATHEXT extensions (`netcoredbg` is `netcoredbg.exe`). + */ +function executableNames(command: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string[] { + if (platform !== "win32" || pathRules(platform).extname(command) !== "") { + return [command]; + } + const pathext = envValue(env, "PATHEXT", platform); + return (hasText(pathext) ? pathext : DEFAULT_PATHEXT) + .split(";") + .filter((extension) => extension !== "") + .map((extension) => `${command}${extension.toLowerCase()}`); +} + +/** Where a bare command is looked up: PATH and PATHEXT from `env`, the path rules of `platform`. */ +export type PathLookup = Pick; + +/** + * First directory on PATH that contains `command`, or undefined. PATH, its + * separator and executable extensions follow `lookup.platform`, not the host. + */ +export function findOnPath(command: string, lookup: PathLookup): string | undefined { + const { env, existsSync: fileExists, platform } = lookup; + const rules = pathRules(platform); + const names = executableNames(command, env, platform); + return pathDirectories(env, platform) + .flatMap((dir) => names.map((name) => rules.join(dir, name))) + .find((candidate) => fileExists(candidate)); } -/** First directory on PATH that contains `command`, or undefined. */ +/** {@link findOnPath} with this host's platform rules. */ export function findExecutableOnPath( command: string, env: NodeJS.ProcessEnv, fileExists: (filePath: string) => boolean, ): string | undefined { - return pathDirectories(env) - .map((dir) => path.join(dir, command)) - .find((candidate) => fileExists(candidate)); + return findOnPath(command, { env, existsSync: fileExists, platform: process.platform }); } function resolveConfigured( @@ -72,7 +122,7 @@ function resolveConfigured( if (looksLikePath(configured)) { return fileExists(configured) ? configured : undefined; } - return findExecutableOnPath(configured, req.env, fileExists); + return findOnPath(configured, req); } /** Every bare command name to try on PATH, primary name first. */ @@ -81,9 +131,8 @@ function adapterCommandNames(req: AdapterResolutionRequest): string[] { } function resolveFromPathNames(req: AdapterResolutionRequest): string | undefined { - const { existsSync: fileExists } = req; return adapterCommandNames(req) - .map((name) => findExecutableOnPath(name, req.env, fileExists)) + .map((name) => findOnPath(name, req)) .find((found) => hasText(found)); } diff --git a/packages/lsp-profiler-ui/src/debug/test/adapter-resolution.test.ts b/packages/lsp-profiler-ui/src/debug/test/adapter-resolution.test.ts index 315dffd..add9f25 100644 --- a/packages/lsp-profiler-ui/src/debug/test/adapter-resolution.test.ts +++ b/packages/lsp-profiler-ui/src/debug/test/adapter-resolution.test.ts @@ -1,7 +1,9 @@ import * as assert from "node:assert"; +import path from "node:path"; import type { AdapterResolutionRequest } from "../adapter-resolution"; import { findExecutableOnPath, + findOnPath, looksLikePath, missingAdapterMessage, resolveAdapterCommand, @@ -32,25 +34,64 @@ suite("looksLikePath", () => { }); }); -suite("findExecutableOnPath", () => { +suite("findOnPath", () => { test("returns the first PATH dir that holds the command", () => { - const found = findExecutableOnPath( - "lldb-dap", - { PATH: ["/a", "/b"].join(":") }, - (candidate) => candidate === "/b/lldb-dap", - ); + const found = findOnPath("lldb-dap", { env: { PATH: ["/a", "/b"].join(":") }, existsSync: (candidate) => candidate === "/b/lldb-dap", platform: "linux" }); assert.strictEqual(found, "/b/lldb-dap"); }); test("skips empty PATH segments and returns undefined when absent", () => { - const found = findExecutableOnPath( - "lldb-dap", - { PATH: ":/x:" }, - () => false, - ); + const found = findOnPath("lldb-dap", { env: { PATH: ":/x:" }, existsSync: () => false, platform: "linux" }); assert.strictEqual(found, undefined); }); test("tolerates an unset PATH", () => { - assert.strictEqual(findExecutableOnPath("x", {}, () => true), undefined); + assert.strictEqual(findOnPath("x", { env: {}, existsSync: () => true, platform: "linux" }), undefined); + assert.strictEqual(findOnPath("x", { env: {}, existsSync: () => true, platform: "win32" }), undefined); + }); + test("follows the requested platform's rules, never the host's", () => { + const posix = findOnPath("lldb-dap", { env: { PATH: "/a:/b" }, existsSync: (candidate) => candidate === "/b/lldb-dap", platform: "darwin" }); + assert.strictEqual(posix, "/b/lldb-dap"); + }); + test("on Windows, splits on ';', reads Path in any case and adds PATHEXT", () => { + const env = { Path: String.raw`C:\a;;C:\tools`, PATHEXT: ".COM;.EXE" }; + const found = findOnPath("netcoredbg", { env, existsSync: (candidate) => candidate === String.raw`C:\tools\netcoredbg.exe`, platform: "win32" }); + assert.strictEqual(found, String.raw`C:\tools\netcoredbg.exe`); + }); + test("on Windows, a bare name without an extension never matches", () => { + const found = findOnPath("netcoredbg", { env: { PATH: String.raw`C:\tools` }, existsSync: (candidate) => candidate === String.raw`C:\tools\netcoredbg`, platform: "win32" }); + assert.strictEqual(found, undefined); + }); + test("on Windows, unset PATHEXT falls back to .COM .EXE .BAT .CMD", () => { + const found = findOnPath("lldb-dap", { env: { PATH: String.raw`C:\llvm\bin` }, existsSync: (candidate) => candidate === String.raw`C:\llvm\bin\lldb-dap.cmd`, platform: "win32" }); + assert.strictEqual(found, String.raw`C:\llvm\bin\lldb-dap.cmd`); + }); + test("on Windows, a command that already has an extension is used as given", () => { + const found = findOnPath("lldb-dap.exe", { env: { PATH: String.raw`C:\llvm\bin`, PATHEXT: ".EXE" }, existsSync: (candidate) => candidate === String.raw`C:\llvm\bin\lldb-dap.exe`, platform: "win32" }); + assert.strictEqual(found, String.raw`C:\llvm\bin\lldb-dap.exe`); + }); +}); + +suite("findExecutableOnPath", () => { + test("looks up with this host's separator and executable names", () => { + const tool = process.platform === "win32" ? "tool.exe" : "tool"; + const dirs = [path.join("a", "bin"), path.join("b", "bin")]; + const found = findExecutableOnPath( + "tool", + { PATH: dirs.join(path.delimiter), PATHEXT: ".EXE" }, + (candidate) => candidate === path.join("b", "bin", tool), + ); + assert.strictEqual(found, path.join("b", "bin", tool)); + }); +}); + +suite("resolveAdapterPath on Windows", () => { + test("a setting's bare name resolves through Path and PATHEXT", () => { + const request = req({ + platform: "win32", + settingValue: "lldb-dap", + env: { Path: String.raw`C:\llvm\bin`, PATHEXT: ".EXE" }, + existsSync: (candidate) => candidate === String.raw`C:\llvm\bin\lldb-dap.exe`, + }); + assert.strictEqual(resolveAdapterPath(request), String.raw`C:\llvm\bin\lldb-dap.exe`); }); }); From a77613148936bbebfcd420cb38cedc6e4cf9c15f Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 08:05:05 +1100 Subject: [PATCH 38/39] Split uri_to_native and WindowsPath::from_native under 20 lines: decode_segments, native_parts, unc_after_root --- crates/lspkit-server/src/uri.rs | 55 +++++++++++++++++++-------------- 1 file changed, 32 insertions(+), 23 deletions(-) diff --git a/crates/lspkit-server/src/uri.rs b/crates/lspkit-server/src/uri.rs index 92015f4..64d37ca 100644 --- a/crates/lspkit-server/src/uri.rs +++ b/crates/lspkit-server/src/uri.rs @@ -86,19 +86,7 @@ fn uri_to_native(uri: &str, style: Style) -> Result { let host = percent_decode(authority)?; let local = host.is_empty() || host.eq_ignore_ascii_case(LOCAL_HOST); let no_path = || UriError::NoLocalPath(uri.to_owned()); - // Each segment is decoded on its own, so an encoded `%2F` (or `%5C` on - // Windows) stays inside its name and is rejected, never split on. - let segments = path - .split('/') - .skip(1) - .map(percent_decode) - .collect::, _>>()?; - if segments - .iter() - .any(|segment| segment.contains(style.separators())) - { - return Err(no_path()); - } + let segments = decode_segments(path, style)?.ok_or_else(no_path)?; match (style, local) { (Style::Unix, true) => Ok(format!("/{}", segments.join("/"))), (Style::Unix, false) => Err(no_path()), @@ -108,6 +96,20 @@ fn uri_to_native(uri: &str, style: Style) -> Result { } } +/// Decodes each path segment on its own, so an encoded `%2F` (or `%5C` on +/// Windows) stays inside its name; `None` when a decoded name holds one. +fn decode_segments(path: &str, style: Style) -> Result>, UriError> { + let segments = path + .split('/') + .skip(1) + .map(percent_decode) + .collect::, _>>()?; + let split = segments + .iter() + .any(|segment| segment.contains(style.separators())); + Ok((!split).then_some(segments)) +} + impl Style { /// Characters that separate path segments, so never appear inside one. const fn separators(self) -> &'static [char] { @@ -146,6 +148,11 @@ fn native_to_uri(path: &str, style: Style) -> Option { } } +/// A native Windows path split on both separators. +fn native_parts(path: &str) -> impl Iterator + '_ { + path.split(['\\', '/']).map(str::to_owned) +} + /// Where an absolute Windows path is rooted. enum Root { /// `C:\`; the letter is upper case. @@ -190,23 +197,25 @@ impl WindowsPath { /// Parses an absolute Windows path, removing an extended-length prefix. /// Device paths (`\\.\`, `\\?\Volume{…}`) name no file and give `None`. fn from_native(path: &str) -> Option { - let is_separator = |c: char| c == '\\' || c == '/'; if let Some(unc) = path.strip_prefix(VERBATIM_UNC_PREFIX) { - let mut parts = unc.split(is_separator).map(str::to_owned); + let mut parts = native_parts(unc); let host = parts.next()?; return Self::unc(&host, parts); } - if let Some(drive) = path.strip_prefix(VERBATIM_PREFIX) { - let mut parts = drive.split(is_separator).map(str::to_owned); - let first = parts.next()?; - return Self::drive(&first, parts); - } - let mut parts = path.split(is_separator).map(str::to_owned); + let (verbatim, body) = match path.strip_prefix(VERBATIM_PREFIX) { + Some(drive) => (true, drive), + None => (false, path), + }; + let mut parts = native_parts(body); let first = parts.next()?; - if !first.is_empty() { + if verbatim || !first.is_empty() { return Self::drive(&first, parts); } - // A leading separator must be the pair that opens `\\server\share`. + Self::unc_after_root(parts) + } + + /// A leading separator must be the pair that opens `\\server\share`. + fn unc_after_root(mut parts: impl Iterator) -> Option { let host = parts .next() .filter(String::is_empty) From da7a9a650b9d0826817c254022ea36abf4180e78 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Wed, 18 Nov 2026 08:06:51 +1100 Subject: [PATCH 39/39] Path handling: no unwrap_or in the watcher's root rebase or the profiler's normalize_path Both fallbacks are explicit matches now: a path outside the reported root is kept, and a path canonicalize cannot resolve keeps its spelling. Co-Authored-By: Claude Opus 5.5 --- crates/lsp-profiler/src/paths.rs | 5 ++++- crates/lspkit-server/src/live/watcher.rs | 9 ++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/crates/lsp-profiler/src/paths.rs b/crates/lsp-profiler/src/paths.rs index d7c82ac..26945a7 100644 --- a/crates/lsp-profiler/src/paths.rs +++ b/crates/lsp-profiler/src/paths.rs @@ -21,5 +21,8 @@ pub fn path_in_roots(candidate: &Path, roots: &[PathBuf]) -> bool { /// Canonicalize existing paths, retaining the original spelling if unavailable. #[must_use] pub fn normalize_path(path: &Path) -> PathBuf { - path.canonicalize().unwrap_or_else(|_| path.to_path_buf()) + match path.canonicalize() { + Ok(canonical) => canonical, + Err(_unresolvable) => path.to_path_buf(), + } } diff --git a/crates/lspkit-server/src/live/watcher.rs b/crates/lspkit-server/src/live/watcher.rs index bbb213d..26dd7dd 100644 --- a/crates/lspkit-server/src/live/watcher.rs +++ b/crates/lspkit-server/src/live/watcher.rs @@ -156,11 +156,10 @@ impl RootAlias { /// The same file under the given root; a path outside the reported root is kept. fn rebase(&self, path: PathBuf) -> PathBuf { - let rebased = path - .strip_prefix(&self.reported) - .ok() - .map(|rest| self.given.join(rest)); - rebased.unwrap_or(path) + match path.strip_prefix(&self.reported) { + Ok(rest) => self.given.join(rest), + Err(_outside_the_reported_root) => path, + } } }