Lightweight coding agent that runs in your terminal
Rust
Reduce response serialization and rollout scan overhead (#36006)
acrognale-oaic41a38dd104e
diff --git a/codex-rs/analytics/src/client.rs b/codex-rs/analytics/src/client.rsindex 74ff18508a..db53fa4aca 100644--- a/codex-rs/analytics/src/client.rs+++ b/codex-rs/analytics/src/client.rs@@ -485,7 +485,7 @@ impl AnalyticsEventsClient {&self,connection_id: u64,request_id: RequestId,- response: ClientResponsePayload,+ response: &ClientResponsePayload,) {self.track_response_inner(connection_id,@@ -499,7 +499,7 @@ impl AnalyticsEventsClient {&self,connection_id: u64,request_id: RequestId,- response: ClientResponsePayload,+ response: &ClientResponsePayload,thread_originator: String,) {self.track_response_inner(connection_id, request_id, response, Some(thread_originator));@@ -509,7 +509,7 @@ impl AnalyticsEventsClient {&self,connection_id: u64,request_id: RequestId,- response: ClientResponsePayload,+ response: &ClientResponsePayload,thread_originator: Option<String>,) {if !matches!(@@ -522,10 +522,13 @@ impl AnalyticsEventsClient {) {return;}+ if serde_json::to_writer(std::io::sink(), response).is_err() {+ return;+ }self.record_fact(AnalyticsFact::ClientResponse {connection_id,request_id,- response: Box::new(response),+ response: Box::new(response.clone()),thread_originator,});}diff --git a/codex-rs/analytics/src/client_tests.rs b/codex-rs/analytics/src/client_tests.rsindex 40e18b2857..ecce99b019 100644--- a/codex-rs/analytics/src/client_tests.rs+++ b/codex-rs/analytics/src/client_tests.rs@@ -614,7 +614,7 @@ fn track_response_only_enqueues_analytics_relevant_responses() {(RequestId::Integer(4), sample_turn_start_response()),(RequestId::Integer(5), sample_turn_steer_response()),] {- client.track_response(/*connection_id*/ 7, request_id, response);+ client.track_response(/*connection_id*/ 7, request_id, &response);assert!(matches!(receiver.try_recv(),Ok(AnalyticsEventsQueueMessage::Fact(input))@@ -625,11 +625,32 @@ fn track_response_only_enqueues_analytics_relevant_responses() {client.track_response(/*connection_id*/ 7,RequestId::Integer(6),- ClientResponsePayload::ThreadArchive(ThreadArchiveResponse {}),+ &ClientResponsePayload::ThreadArchive(ThreadArchiveResponse {}),);assert!(matches!(receiver.try_recv(), Err(TryRecvError::Empty)));}+#[cfg(unix)]+#[test]+fn track_response_ignores_unserializable_thread_responses() {+ use std::ffi::OsString;+ use std::os::unix::ffi::OsStringExt;++ let (client, mut receiver) = client_with_receiver();+ let mut response = sample_thread_start_response();+ let ClientResponsePayload::ThreadStart(thread_start) = &mut response else {+ panic!("expected thread/start response");+ };+ thread_start.cwd = codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(+ std::path::PathBuf::from(OsString::from_vec(vec![b'/', b'b', b'a', b'd', 0xff])),+ )+ .expect("non-UTF-8 Unix paths are valid absolute paths");++ client.track_response(/*connection_id*/ 7, RequestId::Integer(1), &response);++ assert!(matches!(receiver.try_recv(), Err(TryRecvError::Empty)));+}+#[tokio::test]async fn flush_waits_for_preceding_fact_delivery() {let (client, mut receiver) = client_with_receiver();diff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rsindex 63471e6599..0ae2fcb860 100644--- a/codex-rs/app-server-protocol/src/protocol/common.rs+++ b/codex-rs/app-server-protocol/src/protocol/common.rs@@ -315,7 +315,8 @@ macro_rules! client_request_definitions {}}- #[derive(Debug, Clone)]+ #[derive(Debug, Clone, Serialize)]+ #[serde(untagged)]#[allow(clippy::large_enum_variant)]pub enum ClientResponsePayload {$( $variant($response), )*@@ -323,26 +324,6 @@ macro_rules! client_request_definitions {}impl ClientResponsePayload {- pub fn into_jsonrpc_parts_and_payload(- self,- request_id: RequestId,- ) -> std::result::Result<- (RequestId, crate::Result, Option<ClientResponsePayload>),- serde_json::Error,- > {- match self {- $(- Self::$variant(response) => {- let result = serde_json::to_value(&response)?;- Ok((request_id, result, Some(Self::$variant(response))))- }- )*- Self::InterruptConversation(response) => {- serde_json::to_value(response).map(|result| (request_id, result, None))- }- }- }-pub fn into_client_response(self, request_id: RequestId) -> Option<ClientResponse> {match self {$(diff --git a/codex-rs/app-server-protocol/src/protocol/common_tests.rs b/codex-rs/app-server-protocol/src/protocol/common_tests.rsindex 83e5d37117..1a10dc0e49 100644--- a/codex-rs/app-server-protocol/src/protocol/common_tests.rs+++ b/codex-rs/app-server-protocol/src/protocol/common_tests.rs@@ -5,18 +5,13 @@ use pretty_assertions::assert_eq;use serde_json::json;#[test]-fn client_response_payload_returns_jsonrpc_parts_and_client_response() -> Result<()> {- let (request_id, result, payload) =- ClientResponsePayload::ThreadArchive(v2::ThreadArchiveResponse {})- .into_jsonrpc_parts_and_payload(RequestId::Integer(7))?;-- assert_eq!(request_id, RequestId::Integer(7));- assert_eq!(result, json!({}));-+fn client_response_payload_serializes_without_an_intermediate_json_value() -> Result<()> {+ let payload = ClientResponsePayload::ThreadArchive(v2::ThreadArchiveResponse {});+ assert_eq!(serde_json::to_string(&payload)?, "{}");let Some(ClientResponse::ThreadArchive {request_id,response: _,- }) = payload.and_then(|payload| payload.into_client_response(RequestId::Integer(7)))+ }) = payload.into_client_response(RequestId::Integer(7))else {panic!("expected thread/archive client response");};@@ -26,19 +21,19 @@ fn client_response_payload_returns_jsonrpc_parts_and_client_response() -> Result#[test]fn interrupt_conversation_payload_stays_jsonrpc_only() -> Result<()> {- let (request_id, result, payload) =- ClientResponsePayload::InterruptConversation(v1::InterruptConversationResponse {- abort_reason: TurnAbortReason::Interrupted,- })- .into_jsonrpc_parts_and_payload(RequestId::Integer(8))?;-- assert_eq!(request_id, RequestId::Integer(8));+ let payload = ClientResponsePayload::InterruptConversation(v1::InterruptConversationResponse {+ abort_reason: TurnAbortReason::Interrupted,+ });assert_eq!(- result,+ serde_json::to_value(&payload)?,json!({"abortReason": "interrupted",}));- assert!(payload.is_none());+ assert!(+ payload+ .into_client_response(RequestId::Integer(8))+ .is_none()+ );Ok(())}diff --git a/codex-rs/app-server-transport/src/outgoing_message.rs b/codex-rs/app-server-transport/src/outgoing_message.rsindex 4aece351d6..7f60ceb44b 100644--- a/codex-rs/app-server-transport/src/outgoing_message.rs+++ b/codex-rs/app-server-transport/src/outgoing_message.rs@@ -1,8 +1,8 @@use std::fmt;+use codex_app_server_protocol::ClientResponsePayload;use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::RequestId;-use codex_app_server_protocol::Result;use codex_app_server_protocol::ServerNotificationEnvelope;use codex_app_server_protocol::ServerRequest;use serde::Serialize;@@ -31,10 +31,10 @@ pub enum OutgoingMessage {Error(OutgoingError),}-#[derive(Debug, Clone, PartialEq, Serialize)]+#[derive(Debug, Clone, Serialize)]pub struct OutgoingResponse {pub id: RequestId,- pub result: Result,+ pub result: Box<ClientResponsePayload>,}#[derive(Debug, Clone, PartialEq, Serialize)]diff --git a/codex-rs/app-server-transport/src/transport/mod.rs b/codex-rs/app-server-transport/src/transport/mod.rsindex 2108ce77c8..c8b0e57e44 100644--- a/codex-rs/app-server-transport/src/transport/mod.rs+++ b/codex-rs/app-server-transport/src/transport/mod.rs@@ -6,6 +6,7 @@ use crate::outgoing_message::OutgoingMessage;use crate::outgoing_message::QueuedOutgoingMessage;use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::JSONRPCMessage;+use codex_app_server_protocol::RequestId;use codex_core::config::find_codex_home;use codex_utils_absolute_path::AbsolutePathBuf;use std::net::SocketAddr;@@ -47,6 +48,7 @@ pub use unix_socket::prepare_control_socket_path;pub use unix_socket::start_control_socket_acceptor;pub use websocket::start_websocket_acceptor;+const INTERNAL_ERROR_CODE: i64 = -32603;const OVERLOADED_ERROR_CODE: i64 = -32001;const APP_SERVER_CONTROL_SOCKET_DIR_NAME: &str = "app-server-control";@@ -260,14 +262,35 @@ fn serialize_outgoing_message(outgoing_message: OutgoingMessage) -> Option<StrinOk(json) => Some(json),Err(err) => {error!("Failed to serialize JSONRPCMessage: {err}");- None+ let OutgoingMessage::Response(response) = outgoing_message else {+ return None;+ };+ serde_json::to_string(&response_serialization_error(response.id, err))+ .inspect_err(|err| error!("Failed to serialize JSONRPC error: {err}"))+ .ok()}}}+fn response_serialization_error(+ request_id: RequestId,+ err: impl std::fmt::Display,+) -> OutgoingMessage {+ OutgoingMessage::Error(OutgoingError {+ id: request_id,+ error: JSONRPCErrorError {+ code: INTERNAL_ERROR_CODE,+ message: format!("failed to serialize response: {err}"),+ data: None,+ },+ })+}+#[cfg(test)]mod tests {use super::*;+ use crate::outgoing_message::OutgoingResponse;+ use codex_app_server_protocol::ClientResponsePayload;use codex_app_server_protocol::ConfigWarningNotification;use codex_app_server_protocol::JSONRPCNotification;use codex_app_server_protocol::JSONRPCRequest;@@ -275,6 +298,7 @@ mod tests {use codex_app_server_protocol::RequestId;use codex_app_server_protocol::ServerNotification;use codex_app_server_protocol::ServerNotificationEnvelope;+ use codex_app_server_protocol::ThreadArchiveResponse;use pretty_assertions::assert_eq;use serde_json::json;use tokio::time::Duration;@@ -314,6 +338,60 @@ mod tests {);}+ #[test]+ fn serialize_typed_response_preserves_wire_shape() {+ let message = OutgoingMessage::Response(OutgoingResponse {+ id: RequestId::Integer(7),+ result: Box::new(ClientResponsePayload::ThreadArchive(+ ThreadArchiveResponse {},+ )),+ });++ let json = serialize_outgoing_message(message).expect("message should serialize");+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&json).expect("message should be valid JSON"),+ json!({ "id": 7, "result": {} })+ );+ }++ #[cfg(unix)]+ #[test]+ fn serialize_invalid_typed_response_returns_jsonrpc_error() {+ use std::ffi::OsString;+ use std::os::unix::ffi::OsStringExt;+ use std::path::PathBuf;++ let codex_home =+ AbsolutePathBuf::from_absolute_path(PathBuf::from(OsString::from_vec(vec![+ b'/', b'b', b'a', b'd', 0xff,+ ])))+ .expect("non-UTF-8 Unix paths are valid absolute paths");+ let message = OutgoingMessage::Response(OutgoingResponse {+ id: RequestId::Integer(7),+ result: Box::new(ClientResponsePayload::Initialize(+ codex_app_server_protocol::InitializeResponse {+ user_agent: "codex-test-agent".to_string(),+ codex_home,+ platform_family: "unix".to_string(),+ platform_os: "linux".to_string(),+ },+ )),+ });++ let json = serialize_outgoing_message(message)+ .expect("invalid response should serialize as a JSON-RPC error");+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&json).expect("message should be valid JSON"),+ json!({+ "id": 7,+ "error": {+ "code": -32603,+ "message": "failed to serialize response: path contains invalid UTF-8 characters",+ }+ })+ );+ }+#[tokio::test]async fn enqueue_incoming_request_returns_overload_error_when_queue_is_full() {let connection_id = ConnectionId(42);diff --git a/codex-rs/app-server-transport/src/transport/remote_control/segment.rs b/codex-rs/app-server-transport/src/transport/remote_control/segment.rsindex ab0d23a881..f14d62e4f2 100644--- a/codex-rs/app-server-transport/src/transport/remote_control/segment.rs+++ b/codex-rs/app-server-transport/src/transport/remote_control/segment.rs@@ -4,6 +4,8 @@ use super::protocol::ClientId;use super::protocol::ServerEnvelope;use super::protocol::ServerEvent;use super::protocol::StreamId;+use crate::outgoing_message::OutgoingMessage;+use crate::transport::response_serialization_error;use base64::DecodeSliceError;use base64::Engine;use codex_app_server_protocol::JSONRPCMessage;@@ -303,7 +305,25 @@ pub(super) fn split_server_envelope_for_transport(return Ok(vec![envelope]);}- let envelope_size_bytes = serialized_len(&envelope)?;+ let envelope_size_bytes = match serialized_len(&envelope) {+ Ok(envelope_size_bytes) => envelope_size_bytes,+ Err(err) => {+ let ServerEvent::ServerMessage { message } = envelope.event else {+ unreachable!("server message variant checked above");+ };+ let OutgoingMessage::Response(response) = *message else {+ return Err(err);+ };+ return Ok(vec![ServerEnvelope {+ event: ServerEvent::ServerMessage {+ message: Box::new(response_serialization_error(response.id, err)),+ },+ client_id: envelope.client_id,+ stream_id: envelope.stream_id,+ seq_id: envelope.seq_id,+ }]);+ }+ };if envelope_size_bytes <= REMOTE_CONTROL_SEGMENT_MAX_BYTES {return Ok(vec![envelope]);}diff --git a/codex-rs/app-server-transport/src/transport/remote_control/segment_tests.rs b/codex-rs/app-server-transport/src/transport/remote_control/segment_tests.rsindex 37c5df6772..3b2406b6f1 100644--- a/codex-rs/app-server-transport/src/transport/remote_control/segment_tests.rs+++ b/codex-rs/app-server-transport/src/transport/remote_control/segment_tests.rs@@ -9,13 +9,25 @@ use super::segment::ClientSegmentReassembler;use super::segment::REMOTE_CONTROL_SEGMENT_MAX_BYTES;use super::segment::split_server_envelope_for_transport;use crate::outgoing_message::OutgoingMessage;+#[cfg(unix)]+use crate::outgoing_message::OutgoingResponse;use base64::Engine;+#[cfg(unix)]+use codex_app_server_protocol::ClientResponsePayload;use codex_app_server_protocol::ConfigWarningNotification;+#[cfg(unix)]+use codex_app_server_protocol::InitializeResponse;use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::JSONRPCNotification;+#[cfg(unix)]+use codex_app_server_protocol::RequestId;use codex_app_server_protocol::ServerNotification;use codex_app_server_protocol::ServerNotificationEnvelope;+#[cfg(unix)]+use codex_utils_absolute_path::AbsolutePathBuf;use pretty_assertions::assert_eq;+#[cfg(unix)]+use serde_json::json;#[test]fn reassembles_client_message_chunks() {@@ -108,6 +120,54 @@ fn splits_large_server_messages_into_wire_chunks() {}));}+#[cfg(unix)]+#[test]+fn invalid_response_becomes_remote_control_jsonrpc_error() {+ use std::ffi::OsString;+ use std::os::unix::ffi::OsStringExt;+ use std::path::PathBuf;++ let codex_home = AbsolutePathBuf::from_absolute_path(PathBuf::from(OsString::from_vec(vec![+ b'/', b'b', b'a', b'd', 0xff,+ ])))+ .expect("non-UTF-8 Unix paths are valid absolute paths");+ let envelope = ServerEnvelope {+ event: ServerEvent::ServerMessage {+ message: Box::new(OutgoingMessage::Response(OutgoingResponse {+ id: RequestId::Integer(7),+ result: Box::new(ClientResponsePayload::Initialize(InitializeResponse {+ user_agent: "codex-test-agent".to_string(),+ codex_home,+ platform_family: "unix".to_string(),+ platform_os: "linux".to_string(),+ })),+ })),+ },+ client_id: ClientId("client-1".to_string()),+ stream_id: StreamId("stream-1".to_string()),+ seq_id: 9,+ };++ let envelopes = split_server_envelope_for_transport(envelope)+ .expect("invalid response should become a remote-control JSON-RPC error");+ assert_eq!(+ serde_json::to_value(envelopes).expect("error envelope should serialize"),+ json!([{+ "type": "server_message",+ "client_id": "client-1",+ "stream_id": "stream-1",+ "seq_id": 9,+ "message": {+ "id": 7,+ "error": {+ "code": -32603,+ "message": "failed to serialize response: path contains invalid UTF-8 characters",+ }+ }+ }])+ );+}+#[test]fn invalidates_incomplete_stream_assemblies() {let message = JSONRPCMessage::Notification(JSONRPCNotification {diff --git a/codex-rs/app-server-transport/src/transport/remote_control/tests.rs b/codex-rs/app-server-transport/src/transport/remote_control/tests.rsindex bc8fe7a7a0..68297254fa 100644--- a/codex-rs/app-server-transport/src/transport/remote_control/tests.rs+++ b/codex-rs/app-server-transport/src/transport/remote_control/tests.rs@@ -1619,9 +1619,16 @@ async fn remote_control_http_mode_enrolls_before_connecting() {.send(QueuedOutgoingMessage::new(OutgoingMessage::Response(crate::outgoing_message::OutgoingResponse {id: codex_app_server_protocol::RequestId::Integer(11),- result: json!({- "userAgent": "codex-test-agent"- }),+ result: Box::new(+ codex_app_server_protocol::ClientResponsePayload::Initialize(+ codex_app_server_protocol::InitializeResponse {+ user_agent: "codex-test-agent".to_string(),+ codex_home: codex_home.path().abs(),+ platform_family: "test-family".to_string(),+ platform_os: "test-os".to_string(),+ },+ ),+ ),},))).await@@ -1636,6 +1643,9 @@ async fn remote_control_http_mode_enrolls_before_connecting() {"id": 11,"result": {"userAgent": "codex-test-agent",+ "codexHome": codex_home.path(),+ "platformFamily": "test-family",+ "platformOs": "test-os",}}})diff --git a/codex-rs/app-server/src/command_exec.rs b/codex-rs/app-server/src/command_exec.rsindex 197489434c..53449ac092 100644--- a/codex-rs/app-server/src/command_exec.rs+++ b/codex-rs/app-server/src/command_exec.rs@@ -885,8 +885,11 @@ mod tests {panic!("expected execution response after termination");};assert_eq!(response.id, request_id.request_id);- let response: CommandExecResponse =- serde_json::from_value(response.result).expect("deserialize command/exec response");+ let codex_app_server_protocol::ClientResponsePayload::OneOffCommandExec(response) =+ *response.result+ else {+ panic!("expected command/exec response");+ };assert_ne!(response.exit_code, 0);assert_eq!(response.stdout, "");// The deferred response now drains any already-emitted stderr before@@ -961,8 +964,11 @@ mod tests {panic!("expected execution response after cancellation");};assert_eq!(response.id, request_id.request_id);- let response: CommandExecResponse =- serde_json::from_value(response.result).expect("deserialize command/exec response");+ let codex_app_server_protocol::ClientResponsePayload::OneOffCommandExec(response) =+ *response.result+ else {+ panic!("expected command/exec response");+ };assert_ne!(response.exit_code, EXEC_TIMEOUT_EXIT_CODE);}diff --git a/codex-rs/app-server/src/in_process.rs b/codex-rs/app-server/src/in_process.rsindex 07a6f83029..0c85e4c0b6 100644--- a/codex-rs/app-server/src/in_process.rs+++ b/codex-rs/app-server/src/in_process.rs@@ -641,7 +641,10 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessCliematch outgoing_message {OutgoingMessage::Response(response) => {if let Some(response_tx) = pending_request_responses.remove(&response.id) {- let _ = response_tx.send(Ok(response.result));+ let result = serde_json::to_value(response.result).map_err(|err| {+ internal_error(format!("failed to serialize response: {err}"))+ });+ let _ = response_tx.send(result);} else {warn!(request_id = ?response.id,diff --git a/codex-rs/app-server/src/message_processor_tracing_tests.rs b/codex-rs/app-server/src/message_processor_tracing_tests.rsindex 40262c8704..b8e59cb2b7 100644--- a/codex-rs/app-server/src/message_processor_tracing_tests.rs+++ b/codex-rs/app-server/src/message_processor_tracing_tests.rs@@ -450,8 +450,10 @@ async fn read_response<T: serde::de::DeserializeOwned>(if response.id != RequestId::Integer(request_id) {continue;}- return serde_json::from_value(response.result)- .expect("response payload should deserialize");+ return serde_json::from_value(+ serde_json::to_value(response.result).expect("response payload should serialize"),+ )+ .expect("response payload should deserialize");}}diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rsindex ae5ea7e538..cb658e497b 100644--- a/codex-rs/app-server/src/outgoing_message.rs+++ b/codex-rs/app-server/src/outgoing_message.rs@@ -538,53 +538,37 @@ impl OutgoingMessageSender {) {let connection_id = request_id.connection_id;let request_id_for_analytics = request_id.request_id.clone();- let serialized_response = response- .into_jsonrpc_parts_and_payload(request_id.request_id.clone())- .map(|(id, result, response)| {- if let Some(response) = response {- match thread_originator {- Some(thread_originator) => {- self.analytics_events_client- .track_response_with_thread_originator(- connection_id.0,- request_id_for_analytics,- response,- thread_originator,- );- }- None => {- self.analytics_events_client.track_response(- connection_id.0,- request_id_for_analytics,- response,- );- }- }- }- (id, result)- });- let request_context = self.take_request_context(&request_id).await;-- match serialized_response {- Ok((id, result)) => {- let outgoing_message = OutgoingMessage::Response(OutgoingResponse { id, result });- self.send_outgoing_message_to_connection(- request_context,- connection_id,- outgoing_message,- "response",- )- .await;+ match thread_originator {+ Some(thread_originator) => {+ self.analytics_events_client+ .track_response_with_thread_originator(+ connection_id.0,+ request_id_for_analytics,+ &response,+ thread_originator,+ );}- Err(err) => {- self.send_error_inner(- request_context,- request_id,- internal_error(format!("failed to serialize response: {err}")),- )- .await;+ None => {+ self.analytics_events_client.track_response(+ connection_id.0,+ request_id_for_analytics,+ &response,+ );}}+ let response = Box::new(response);+ let request_context = self.take_request_context(&request_id).await;+ let outgoing_message = OutgoingMessage::Response(OutgoingResponse {+ id: request_id.request_id,+ result: response,+ });+ self.send_outgoing_message_to_connection(+ request_context,+ connection_id,+ outgoing_message,+ "response",+ )+ .await;}pub(crate) async fn send_server_notification(&self, notification: ServerNotification) {@@ -1087,7 +1071,10 @@ mod tests {panic!("expected response message");};assert_eq!(response.id, request_id.request_id);- assert_eq!(response.result, json!({}));+ assert_eq!(+ serde_json::to_value(response.result).expect("result should serialize"),+ json!({})+ );}other => panic!("expected targeted response envelope, got: {other:?}"),}diff --git a/codex-rs/rollout/src/reverse_jsonl_scanner.rs b/codex-rs/rollout/src/reverse_jsonl_scanner.rsindex cf6b6b8e9d..71c5880f9a 100644--- a/codex-rs/rollout/src/reverse_jsonl_scanner.rs+++ b/codex-rs/rollout/src/reverse_jsonl_scanner.rs@@ -5,7 +5,7 @@ use std::io::SeekFrom;use serde::de::DeserializeOwned;-const READ_CHUNK_SIZE: usize = 8 * 1024;+const READ_CHUNK_SIZE: usize = 64 * 1024;#[derive(Debug)]pub enum ScanOutcome<T> {@@ -64,39 +64,34 @@ whereT: DeserializeOwned,{loop {- let Some(byte) = self.read_previous_byte()? else {- return Ok(self.finish_record());- };+ if self.chunk_position == 0 {+ if self.next_chunk_end == 0 {+ return Ok(self.finish_record());+ }- if byte != b'\n' {- self.record_reversed.push(byte);- continue;+ let read_size = usize::try_from(self.next_chunk_end.min(READ_CHUNK_SIZE as u64))+ .map_err(io::Error::other)?;+ self.next_chunk_end -= read_size as u64;+ self.reader.seek(SeekFrom::Start(self.next_chunk_end))?;+ self.reader.read_exact(&mut self.chunk[..read_size])?;+ self.chunk_position = read_size;}- if let Some(outcome) = self.finish_record() {- return Ok(Some(outcome));+ let chunk = &self.chunk[..self.chunk_position];+ if let Some(newline_position) = chunk.iter().rposition(|byte| *byte == b'\n') {+ self.record_reversed+ .extend(chunk[newline_position + 1..].iter().rev().copied());+ self.chunk_position = newline_position;+ if let Some(outcome) = self.finish_record() {+ return Ok(Some(outcome));+ }+ } else {+ self.record_reversed.extend(chunk.iter().rev().copied());+ self.chunk_position = 0;}}}- fn read_previous_byte(&mut self) -> io::Result<Option<u8>> {- if self.chunk_position == 0 {- if self.next_chunk_end == 0 {- return Ok(None);- }-- let read_size = usize::try_from(self.next_chunk_end.min(READ_CHUNK_SIZE as u64))- .map_err(io::Error::other)?;- self.next_chunk_end -= read_size as u64;- self.reader.seek(SeekFrom::Start(self.next_chunk_end))?;- self.reader.read_exact(&mut self.chunk[..read_size])?;- self.chunk_position = read_size;- }-- self.chunk_position -= 1;- Ok(Some(self.chunk[self.chunk_position]))- }-fn finish_record<T>(&mut self) -> Option<ScanOutcome<T>>whereT: DeserializeOwned,