16 files changed, 18 insertions, 18 deletions
diff --git a/crates/arti-client/src/rpc.rs b/crates/arti-client/src/rpc.rs
index 3ba311d2f..30b6dc310 100644
--- a/crates/arti-client/src/rpc.rs
+++ b/crates/arti-client/src/rpc.rs
@@ -131,7 +131,7 @@ async fn watch_client_status<R: Runtime>(
 /// Returned ObjectID is a handle for a new `TorClient`,
 /// which is isolated from other `TorClients`:
 /// any streams created with the new `TorClient` will not share circuits
-/// with streams crated with any other `TorClient`.
+/// with streams created with any other `TorClient`.
 #[derive(Deftly, Debug, Serialize, Deserialize)]
 #[derive_deftly(rpc::DynMethod)]
 #[deftly(rpc(method_name = "arti:new_isolated_client"))]
diff --git a/crates/arti-rpc-client-core/src/conn/connimpl.rs b/crates/arti-rpc-client-core/src/conn/connimpl.rs
index e5f45ac4b..025318b25 100644
--- a/crates/arti-rpc-client-core/src/conn/connimpl.rs
+++ b/crates/arti-rpc-client-core/src/conn/connimpl.rs
@@ -269,7 +269,7 @@ impl Receiver {
     ) -> Result<ValidatedResponse, ProtoError> {
         // Here in wait_on_message_for_impl, we do the the actual work
         // of waiting for the message.
-        let state = self.state.lock().expect("posioned");
+        let state = self.state.lock().expect("poisoned");
         let (result, mut state, should_alert) = self.wait_on_message_for_impl(state, id);
 
         // Great; we have a message or a fatal error.  All we need to do now
diff --git a/crates/arti/src/socks.rs b/crates/arti/src/socks.rs
index 05c832cde..3b2527419 100644
--- a/crates/arti/src/socks.rs
+++ b/crates/arti/src/socks.rs
@@ -326,7 +326,7 @@ fn interpret_socks_auth(auth: &SocksAuth) -> Result<AuthInterpretation> {
             return Ok(Uname::Legacy);
         };
         if remainder.is_empty() {
-            return Err(anyhow!("Exteneded SOCKS information without format code."));
+            return Err(anyhow!("Extended SOCKS information without format code."));
         }
         // TODO MSRV 1.80: use split_at_checked instead.
         // This won't panic since we checked for an empty string above.
diff --git a/crates/tor-cell/src/relaycell/hs/pow.rs b/crates/tor-cell/src/relaycell/hs/pow.rs
index abf863861..9234be6b7 100644
--- a/crates/tor-cell/src/relaycell/hs/pow.rs
+++ b/crates/tor-cell/src/relaycell/hs/pow.rs
@@ -9,7 +9,7 @@ use super::intro_payload::IntroPayloadExtType;
 use caret::caret_int;
 use tor_bytes::{EncodeResult, Reader, Result, Writer};
 
-/// Extention to provide a proof of work for denial of service mitigation
+/// Extension to provide a proof of work for denial of service mitigation
 ///
 /// Documented at <https://spec.torproject.org/rend-spec/introduction-protocol.html#INTRO1_POW_EXT>
 ///
diff --git a/crates/tor-chanmgr/src/mgr/select.rs b/crates/tor-chanmgr/src/mgr/select.rs
index 517f19a01..4a4562f9b 100644
--- a/crates/tor-chanmgr/src/mgr/select.rs
+++ b/crates/tor-chanmgr/src/mgr/select.rs
@@ -401,7 +401,7 @@ mod test {
 
     #[test]
     fn best_channel_many() {
-        // some misc channels (as we make `choose_best_channel` more complex, hopefull we can add
+        // some misc channels (as we make `choose_best_channel` more complex, hopeful we can add
         // more channels here)
         let channels = [
             ChannelState::Open(open_channel(FakeChannel {
diff --git a/crates/tor-keymgr/src/config.rs b/crates/tor-keymgr/src/config.rs
index 0c210fc8b..9b0485560 100644
--- a/crates/tor-keymgr/src/config.rs
+++ b/crates/tor-keymgr/src/config.rs
@@ -331,7 +331,7 @@ impl ArtiKeystoreConfigBuilder {
         }
 
         let () = match self.primary.kind {
-            // only enabled OR kind may be set, and when keymgr is not enabeld they must be false|disabled
+            // only enabled OR kind may be set, and when keymgr is not enabled they must be false|disabled
             None | Some(EoA::Auto) => Ok(()),
             _ => Err(ConfigBuildError::Inconsistent {
                 fields: ["enabled", "kind"].map(Into::into).into_iter().collect(),
diff --git a/crates/tor-keymgr/src/keystore/ctor/client.rs b/crates/tor-keymgr/src/keystore/ctor/client.rs
index 6536c906d..d85f44c44 100644
--- a/crates/tor-keymgr/src/keystore/ctor/client.rs
+++ b/crates/tor-keymgr/src/keystore/ctor/client.rs
@@ -193,7 +193,7 @@ impl CTorClientKeystore {
 /// format.
 ///
 /// TODO: we might want to move this to tor-hscrypto at some point,
-/// but for now, we don't actually *need* to expose this publically.
+/// but for now, we don't actually *need* to expose this publicly.
 fn parse_client_keypair(
     key: impl AsRef<str>,
 ) -> StdResult<(HsId, HsClientDescEncKeypair), MalformedClientKeyError> {
diff --git a/crates/tor-keymgr/src/keystore/ephemeral.rs b/crates/tor-keymgr/src/keystore/ephemeral.rs
index 713003138..6b20cc69a 100644
--- a/crates/tor-keymgr/src/keystore/ephemeral.rs
+++ b/crates/tor-keymgr/src/keystore/ephemeral.rs
@@ -25,7 +25,7 @@ type KeyIdent = (ArtiPath, KeystoreItemType);
 /// system may do so for reasons outside of this library's control. Some
 /// examples are swapping RAM to disk, generating core dumps, invoking
 /// suspend-to-disk power management, etc. This key store does not attempt to
-/// prevent this operating system behvaiour.
+/// prevent this operating system behaviour.
 pub struct ArtiEphemeralKeystore {
     /// Identifier hard-coded to 'ephemeral'
     id: KeystoreId,
diff --git a/crates/tor-keymgr/src/mgr.rs b/crates/tor-keymgr/src/mgr.rs
index c68b4ab35..e2ac48c34 100644
--- a/crates/tor-keymgr/src/mgr.rs
+++ b/crates/tor-keymgr/src/mgr.rs
@@ -687,7 +687,7 @@ mod tests {
     /// The corresponding fake public key type.
     #[derive(Clone, Debug)]
     struct TestPublicKey {
-        /// The undelying key.
+        /// The underlying key.
         key: KeystoreItem,
     }
 
diff --git a/crates/tor-memquota/src/lib.rs b/crates/tor-memquota/src/lib.rs
index 0792917db..8226d9672 100644
--- a/crates/tor-memquota/src/lib.rs
+++ b/crates/tor-memquota/src/lib.rs
@@ -167,7 +167,7 @@
 //!
 //! In the case of sufficiently bad account errors,
 //! a Participant, or a whole Account, or the whole MemoryQuotaTracker,
-//! may become unuseable,
+//! may become unusable,
 //! in which case methods will return errors with kind [`tor_error::ErrorKind::Internal`].
 //
 // TODO MEMQUOTA: We ought to account for the fixed overhead of each stream, circuit, and
diff --git a/crates/tor-netdoc/src/doc/hsdesc/pow.rs b/crates/tor-netdoc/src/doc/hsdesc/pow.rs
index 2526db749..4228910f9 100644
--- a/crates/tor-netdoc/src/doc/hsdesc/pow.rs
+++ b/crates/tor-netdoc/src/doc/hsdesc/pow.rs
@@ -27,7 +27,7 @@ impl PowParamSet {
     ///
     pub(super) fn from_items(items: &[Item<'_, HsInnerKwd>]) -> Result<Self> {
         // Parse each one individually,
-        // verifing each time we don't have a duplicated enum discriminant.
+        // verifying each time we don't have a duplicated enum discriminant.
         let mut inner = Vec::new();
         let mut schemes_seen: HashSet<Discriminant<PowParams>> = HashSet::new();
         for item in items {
diff --git a/crates/tor-proto/src/util/oneshot_broadcast.rs b/crates/tor-proto/src/util/oneshot_broadcast.rs
index 0ccf935e1..ff1e6c083 100644
--- a/crates/tor-proto/src/util/oneshot_broadcast.rs
+++ b/crates/tor-proto/src/util/oneshot_broadcast.rs
@@ -68,7 +68,7 @@ pub(crate) struct Receiver<T> {
 ///
 /// When the wakers Mutex is released at (C), a release-store operation is performed by the Mutex,
 /// which means that the message set at (A) will be seen by all future acquire-load operations by
-/// that same Mutex. More specifically, after (C) has occured and when the same mutex is acquired at
+/// that same Mutex. More specifically, after (C) has occurred and when the same mutex is acquired at
 /// (D), the message set at (A) is guaranteed to be visible at (E). This means that after the wakers
 /// are taken at (B), no future wakers will be added at (F) and no waker will be "lost".
 #[derive(Debug)]
diff --git a/crates/tor-rpc-connect/src/load.rs b/crates/tor-rpc-connect/src/load.rs
index a7aa991bd..39411959c 100644
--- a/crates/tor-rpc-connect/src/load.rs
+++ b/crates/tor-rpc-connect/src/load.rs
@@ -159,7 +159,7 @@ pub struct LoadOptions {
 #[derive(Clone, Debug, thiserror::Error)]
 #[non_exhaustive]
 pub enum LoadError {
-    /// We couldn't accesss the path.
+    /// We couldn't access the path.
     ///
     /// This can happen if permissions are wrong,
     /// the file doesn't exist, we encounter an IO error, or something similar.
diff --git a/crates/tor-rtcompat/src/coarse_time.rs b/crates/tor-rtcompat/src/coarse_time.rs
index 6cb9c0f63..d7a59f281 100644
--- a/crates/tor-rtcompat/src/coarse_time.rs
+++ b/crates/tor-rtcompat/src/coarse_time.rs
@@ -161,7 +161,7 @@ impl CoarseTimeProvider for RealCoarseTimeProvider {
     }
 }
 
-#[cfg(not(miri))] // TODO coarse_time substracts with overflow!
+#[cfg(not(miri))] // TODO coarse_time subtracts with overflow!
 #[cfg(test)]
 mod test {
     // @@ begin test lint list maintained by maint/add_warning @@
diff --git a/crates/tor-rtmock/src/task.rs b/crates/tor-rtmock/src/task.rs
index 775b48661..adbd6a36c 100644
--- a/crates/tor-rtmock/src/task.rs
+++ b/crates/tor-rtmock/src/task.rs
@@ -194,9 +194,9 @@ enum TaskState {
 struct ActualWaker {
     /// Executor state
     ///
-    /// The Waker musn't to hold a strong reference to the executor,
+    /// The Waker mustn't to hold a strong reference to the executor,
     /// since typically a task holds a future that holds a Waker,
-    /// and the exeuctor holds the task - so that would be a cycle.
+    /// and the executor holds the task - so that would be a cycle.
     data: Weak<Mutex<Data>>,
 
     /// Which task this is
diff --git a/crates/tor-socksproto/src/handshake/framework.rs b/crates/tor-socksproto/src/handshake/framework.rs
index daa749e1c..ad458a43b 100644
--- a/crates/tor-socksproto/src/handshake/framework.rs
+++ b/crates/tor-socksproto/src/handshake/framework.rs
@@ -196,11 +196,11 @@ impl<'b, O, P: ReadPrecision> Finished<'b, O, P> {
 
     /// Return the output, and the following already-read data as a `Vec`
     ///
-    /// The `Vec` is quite likely to have a considerably larger capacity than contnets.
+    /// The `Vec` is quite likely to have a considerably larger capacity than contents.
     /// (Its capacity is usually the original buffer size, when the `Buffer` was created.)
     ///
     /// The `Buffer` should not be discarded after calling this;
-    /// it will not be useable.
+    /// it will not be usable.
     //
     // Ideally, this would *consume* the Buffer.  But that would mean that
     // `step` would have to take and return the buffer,