proto becomes bxcore, the one shared crate (M5b task 00)

Done the way the owner asked and the spike mapped: the crate and the
manifests renamed, then what the build reported fixed. Layers: 138
"proto unresolved" errors across 169 files; cargo fmt reordering
imports; six fixture paths built as strings in brokerd's and bxctl's
tests, which the compiler cannot see, and comments naming
crates/proto/; the crate-dependency check and its self-test. One more
the spike did not reach: a `\nproto =` key inside a printf format in
the self-test, which a word-boundary replacement skips because `n` and
`p` are both word characters.

make gate: gate: ok, 944 tests; no new entry in /tmp.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

crates/gatewayd/Cargo.toml

@@ -9,7 +9,7 @@ publish.workspace = true
 workspace = true
 
 [dependencies]
-proto.workspace = true
+bxcore.workspace = true
 rustls.workspace = true
 rustls-native-certs.workspace = true
 serde.workspace = true

crates/gatewayd/src/approvals/mod.rs

@@ -7,7 +7,7 @@ use std::collections::{HashMap, HashSet};
 use std::sync::mpsc::Sender;
 use std::sync::{Mutex, MutexGuard};
 
-use proto::ApprovalReply;
+use bxcore::ApprovalReply;
 
 use crate::sessions::ApprovalCommand::{self, Approve, Deny, Malformed};
 

crates/gatewayd/src/approvals/text.rs

@@ -1,8 +1,8 @@
 //! The text of an approval's posts, and of the line added when it ends (M4b spec, section 6).
 //! Nothing here is shortened: arguments too long to show whole are not shown at all.
 
-use proto::escape::escape_json_text;
-use proto::{DenyReason, PendingApproval, Timestamp, sha256};
+use bxcore::escape::escape_json_text;
+use bxcore::{DenyReason, PendingApproval, Timestamp, sha256};
 
 /// Arguments are split into parts of at most this many characters.
 pub const PART_CHARS: usize = 15_000;
@@ -196,7 +196,7 @@ pub fn asked_post(id: u64, asked: &Asked) -> String {
     } else {
         "a direct message"
     };
-    let escaped = proto::escape::escape_model_text(&asked.prompt);
+    let escaped = bxcore::escape::escape_model_text(&asked.prompt);
     let total = escaped.chars().count();
     let shown: String = escaped.chars().take(PROMPT_SHOWN).collect();
     let mut post = format!(

crates/gatewayd/src/deliver.rs

@@ -5,7 +5,7 @@ use std::os::unix::net::UnixStream;
 use std::path::Path;
 use std::time::{Duration, Instant};
 
-use proto::{
+use bxcore::{
     Envelope, ErrorCode, Message, PROTOCOL_VERSION, Turn, TurnEvent, WireError, read_frame,
     write_frame,
 };

crates/gatewayd/src/gateway.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
 use std::time::Duration;
 
-use proto::{
+use bxcore::{
     ApprovalPosted, ApprovalReply, Envelope, ErrorCode, FrameError, GatewayOutcome, Message,
     PROTOCOL_VERSION, PendingApproval, WireError, read_frame, write_frame,
 };

crates/gatewayd/src/serve/approvals.rs

@@ -4,7 +4,7 @@
 
 use std::sync::mpsc::Sender;
 
-use proto::{ApprovalReply, GatewayOutcome, PendingApproval};
+use bxcore::{ApprovalReply, GatewayOutcome, PendingApproval};
 
 use crate::approvals::Posted;
 use crate::approvals::text::{self, Asked, Ended};

crates/gatewayd/src/serve/mod.rs

@@ -12,7 +12,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::time::{Duration, Instant};
 
-use proto::SessionId;
+use bxcore::SessionId;
 
 use crate::approvals::Registry;
 use crate::config::Config;

crates/gatewayd/src/sessions.rs

@@ -3,7 +3,7 @@
 
 use std::collections::{BTreeSet, HashMap};
 
-use proto::SessionId;
+use bxcore::SessionId;
 
 use crate::mm::Post;
 
@@ -71,7 +71,7 @@ pub enum ApprovalCommand {
 }
 
 /// The longest reason a `!deny` may give, in characters.
-pub const MAX_REASON: usize = proto::MAX_REASON;
+pub const MAX_REASON: usize = bxcore::MAX_REASON;
 
 /// `!approve …` or `!deny …` as an approval command; `None` for any other text.
 pub fn approval_command(text: &str) -> Option<ApprovalCommand> {

crates/gatewayd/src/ws/handshake.rs

@@ -34,11 +34,11 @@ pub fn base64(bytes: &[u8]) -> String {
 
 /// The `Sec-WebSocket-Accept` a server must send for `key`.
 pub fn accept_for(key: &str) -> String {
-    // base64(sha1(key + GUID)), with `proto::sha1::sha1`.
+    // base64(sha1(key + GUID)), with `bxcore::sha1::sha1`.
     let mut data = Vec::with_capacity(key.len() + GUID.len());
     data.extend_from_slice(key.as_bytes());
     data.extend_from_slice(GUID.as_bytes());
-    base64(&proto::sha1::sha1(&data))
+    base64(&bxcore::sha1::sha1(&data))
 }
 
 /// A fresh key: 16 bytes from `random` (in `gatewayd`, `/dev/urandom`), in base64.

crates/gatewayd/tests/approvals_judge.rs

@@ -3,9 +3,9 @@
 
 use std::sync::mpsc::{self, Receiver};
 
+use bxcore::ApprovalReply;
 use gatewayd::approvals::{Judged, NOT_APPROVER, Posted, Registry, USAGE};
 use gatewayd::sessions::ApprovalCommand::{self, Approve, Deny, Malformed};
-use proto::ApprovalReply;
 
 const KYLE: &str = "k0000000000000000000000000";
 const HERMES: &str = "h0000000000000000000000000";

crates/gatewayd/tests/approvals_text.rs

@@ -1,9 +1,9 @@
 //! The text of an approval's posts and of its ending line (M4b spec, section 6). Do not edit.
 
+use bxcore::{CallId, DataClass, DenyReason, PendingApproval, SessionId, Timestamp, sha256};
 use gatewayd::approvals::text::{
     Ended, MAX_PART_POST, MAX_PARTS, PART_CHARS, code, ended_line, fence, render, with_ending,
 };
-use proto::{CallId, DataClass, DenyReason, PendingApproval, SessionId, Timestamp, sha256};
 
 /// The escape for one code point, built here so this file holds no such character itself.
 fn esc(code: u32) -> String {

crates/gatewayd/tests/deliver.rs

@@ -10,11 +10,11 @@ mod tmp;
 use std::sync::Mutex;
 use std::time::Duration;
 
+use bxcore::{DataClass, ErrorCode, SessionId, Timestamp, TurnEvent};
 use fake_loop::{Reply, done, error, event, serve_loop};
 use gatewayd::deliver::{EMPTY_ANSWER, LOOP_DOWN, MAX_POST, Notice, Poster, deliver, split_answer};
 use gatewayd::mm::MmError;
 use gatewayd::sessions::{Batch, Thread};
-use proto::{DataClass, ErrorCode, SessionId, Timestamp, TurnEvent};
 use tmp::TempDir;
 
 const DM: &str = "d0000000000000000000000000";
@@ -217,11 +217,11 @@ fn a_loop_that_is_not_there_or_goes_away() {
         ],
         vec![Reply::Bytes(b"\x00\x00\x00\x05{bad}".to_vec())],
         vec![
-            Reply::Frame(proto::Envelope {
+            Reply::Frame(bxcore::Envelope {
                 v: 1,
                 id: 2,
                 r#final: true,
-                msg: proto::Message::Ok(proto::Empty {}),
+                msg: bxcore::Message::Ok(bxcore::Empty {}),
             }),
             done("late"),
         ],

crates/gatewayd/tests/deliver_notice.rs

@@ -9,11 +9,11 @@ mod tmp;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
+use bxcore::{SessionId, Timestamp, TurnEvent};
 use fake_loop::{done, event, serve_loop};
 use gatewayd::deliver::{Notice, Poster, deliver};
 use gatewayd::mm::MmError;
 use gatewayd::sessions::{Batch, Thread};
-use proto::{SessionId, Timestamp, TurnEvent};
 use tmp::TempDir;
 
 const DM: &str = "d0000000000000000000000000";

crates/gatewayd/tests/gateway_sock.rs

@@ -12,12 +12,12 @@ use std::sync::mpsc::{self, Receiver};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use gatewayd::gateway::{Ending, Timing, ToLoop, listen, serve};
-use proto::{
+use bxcore::{
     ApprovalOutcome, ApprovalReply, ApprovalRequest, CallId, DataClass, Envelope, ErrorCode,
     GatewayOutcome, Message, PROTOCOL_VERSION, PendingApproval, SessionId, Timestamp, read_frame,
     write_frame,
 };
+use gatewayd::gateway::{Ending, Timing, ToLoop, listen, serve};
 use tmp::TempDir;
 
 const KYLE: &str = "k0000000000000000000000000";

crates/gatewayd/tests/serve_answers.rs

@@ -19,12 +19,12 @@ use std::sync::{Mutex, mpsc};
 use std::time::{Duration, Instant};
 
 use brokerd_client::{Asking, ask, pending};
+use bxcore::{GatewayOutcome, Timestamp, Turn, TurnEvent};
 use fake_loop::{done, event, serve_loop};
 use fake_mm::{DM, EVE, FakeMm, KYLE, WsPeer, id, post};
 use gateway::{Running, WAIT, loop_dir, start};
 use gatewayd::approvals::NOT_APPROVER;
 use gatewayd::config::Config;
-use proto::{GatewayOutcome, Timestamp, Turn, TurnEvent};
 use tmp::TempDir;
 
 /// KYLE and EVE may talk; only KYLE approves.

crates/gatewayd/tests/serve_redirect.rs

@@ -18,11 +18,11 @@ use std::sync::{Mutex, mpsc};
 use std::time::Duration;
 
 use brokerd_client::{Asking, ask, pending};
+use bxcore::{GatewayOutcome, Turn};
 use fake_loop::{done, serve_loop};
 use fake_mm::{DM, EVE, EVE_DM, FakeMm, KYLE, WsPeer, id, post};
 use gateway::{Running, WAIT, loop_dir, start};
 use gatewayd::config::Config;
-use proto::{GatewayOutcome, Turn};
 use tmp::TempDir;
 
 const GROUP: &str = "g0000000000000000000000000";

crates/gatewayd/tests/sessions.rs

@@ -1,12 +1,12 @@
 //! Which posts become turns, in which session, and how messages wait for a running turn (M4a spec,
 //! section 7, including its table of examples). Do not edit.
 
+use bxcore::SessionId;
 use gatewayd::mm::Post;
 use gatewayd::sessions::{
     ApprovalCommand, BUSY, Batch, Ignored, Message, Pushed, Queues, Route, Router, Thread,
     UNKNOWN_COMMAND, named,
 };
-use proto::SessionId;
 
 const BOT: &str = "b0000000000000000000000000";
 const KYLE: &str = "k0000000000000000000000000";

crates/gatewayd/tests/support/brokerd_client.rs

@@ -7,7 +7,7 @@ use std::os::unix::net::UnixStream;
 use std::path::Path;
 use std::time::Duration;
 
-use proto::{
+use bxcore::{
     ApprovalOutcome, ApprovalReply, ApprovalRequest, CallId, DataClass, Envelope, GatewayOutcome,
     Message, PROTOCOL_VERSION, PendingApproval, SessionId, Timestamp, read_frame, write_frame,
 };

crates/gatewayd/tests/support/fake_loop.rs

@@ -8,7 +8,7 @@ use std::os::unix::net::UnixListener;
 use std::path::Path;
 use std::sync::mpsc;
 
-use proto::{
+use bxcore::{
     Envelope, ErrorCode, Message, PROTOCOL_VERSION, Turn, TurnDone, TurnEvent, Usage, WireError,
     read_frame, write_frame,
 };

crates/gatewayd/tests/support/gateway.rs

@@ -8,10 +8,10 @@ use std::sync::{Arc, Mutex, mpsc};
 use std::thread::JoinHandle;
 use std::time::Duration;
 
+use bxcore::Turn;
 use gatewayd::config::Config;
 use gatewayd::secrets::Secret;
 use gatewayd::serve::{Stop, Tuning, run};
-use proto::Turn;
 
 use crate::fake_loop::{done, serve_loop};
 use crate::fake_mm::{FakeMm, KYLE, WsPeer};