@@ -22,7 +22,7 @@ freeze-stdlib = ["stdlib", "rustpython-vm/freeze-stdlib", "rustpython-pylib?/fre
 jit = ["rustpython-vm/jit"]
 threading = ["rustpython-vm/threading", "rustpython-stdlib/threading"]
 sqlite = ["rustpython-stdlib/sqlite"]
-ssl = ["host_env"]
+ssl = ["host_env", "rustpython-stdlib?/ssl"]
 ssl-rustls = ["ssl", "rustpython-stdlib/ssl-rustls"]
 ssl-rustls-aws-lc = ["ssl-rustls", "dep:rustls", "rustls/aws_lc_rs"]
 ssl-rustls-aws-lc-fips = ["ssl-rustls-aws-lc", "rustls/fips"]
 
@@ -1183,7 +1183,6 @@ def __del__(self):
         self.assertEqual(out.strip(), b"OK")
         self.assertIn(b"can't create new thread at interpreter shutdown", err)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_join_daemon_thread_in_finalization(self):
         # gh-123940: Py_Finalize() prevents other threads from running Python
         # code, so join() can not succeed unless the thread is already done.
 
@@ -208,6 +208,7 @@ impl NormalizedParseDiagnostic {
 /// column. These are reconstructed by re-scanning after ruff's parse has already failed, so they
 /// carry CPython's wording rather than a translation of ruff's own error, and they never reach
 /// ruff — `NormalizedParseDiagnostic` and `CompileError` are the only things that consume one.
+#[derive(Clone)]
 struct CpythonDiagnostic {
     message: String,
     range: ruff_text_size::TextRange,
@@ -243,6 +244,52 @@ impl CpythonDiagnostic {
     }
 }
 
+/// Lexer-class failures outrank print hints. Decode and f-string diagnostics
+/// compete with lexer failures by offset, and an unterminated quote is only
+/// a fallback when no decode/f-string diagnostic exists. Print is considered
+/// against the final winner: a later 0x still beats print, but an f-string
+/// that replaced that 0x must not hide an earlier print. A decode diagnostic
+/// also suppresses an EOF unclosed opener.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum OverrideClass {
+    Lexer,
+    Decode,
+    Print,
+}
+
+struct RankedOverride {
+    diagnostic: CpythonDiagnostic,
+    unclosed_bracket: bool,
+    class: OverrideClass,
+}
+
+fn consider_override(
+    best: &mut Option<RankedOverride>,
+    diagnostic: CpythonDiagnostic,
+    class: OverrideClass,
+) {
+    let unclosed_bracket = diagnostic.is_unclosed_bracket;
+    consider_ranked(best, diagnostic, unclosed_bracket, class);
+}
+
+fn consider_ranked(
+    best: &mut Option<RankedOverride>,
+    diagnostic: CpythonDiagnostic,
+    unclosed_bracket: bool,
+    class: OverrideClass,
+) {
+    if best
+        .as_ref()
+        .is_none_or(|current| diagnostic.range.start() < current.diagnostic.range.start())
+    {
+        *best = Some(RankedOverride {
+            diagnostic,
+            unclosed_bracket,
+            class,
+        });
+    }
+}
+
 fn cpython_parse_diagnostic_override(
     error: &parser::ParseError,
     source_file: &SourceFile,
@@ -258,18 +305,80 @@ fn cpython_parse_diagnostic_override(
         };
     }
 
-    source_error!(invalid_number_literal_error(source_text));
-    source_error!(invalid_legacy_statement_error(source_text));
-    source_error!(incompatible_string_prefix_error(source_text));
-    source_error!(malformed_unicode_n_escape_error(source_text));
-    source_error!(non_printable_character_error(source_text));
-    source_error!(invalid_interpolated_string_error(source_text));
-    source_error!(mixed_tstring_literal_error(error, source_text));
-
-    if let Some(bracket) = bracket_syntax_error(source_text) {
+    let mut earliest: Option<RankedOverride> = None;
+    if let Some(diagnostic) = invalid_number_literal_error(source_text) {
+        consider_override(&mut earliest, diagnostic, OverrideClass::Lexer);
+    }
+    if let Some(diagnostic) = incompatible_string_prefix_error(source_text) {
+        consider_override(&mut earliest, diagnostic, OverrideClass::Lexer);
+    }
+    if let Some(diagnostic) = non_printable_character_error(source_text) {
+        consider_override(&mut earliest, diagnostic, OverrideClass::Lexer);
+    }
+    let bracket = bracket_syntax_error(source_text);
+    if let Some(bracket) = bracket.as_ref() {
+        // Unclosed openers are reported at the opener and only become errors
+        // at EOF. A later token-time diagnostic (invalid number, prefix, …)
+        // must keep winning. Mismatched closers stay in the lexer-class
+        // positional ranking.
+        if !bracket.unclosed {
+            consider_ranked(
+                &mut earliest,
+                bracket.diagnostic.clone(),
+                false,
+                OverrideClass::Lexer,
+            );
+        }
+    }
+    let mut saw_decode = false;
+    if let Some(diagnostic) = malformed_unicode_n_escape_error(source_text) {
+        saw_decode = true;
+        consider_override(&mut earliest, diagnostic, OverrideClass::Decode);
+    }
+    if let Some(diagnostic) = invalid_interpolated_string_error(source_text) {
+        saw_decode = true;
+        consider_override(&mut earliest, diagnostic, OverrideClass::Decode);
+    }
+    if let Some(diagnostic) = mixed_tstring_literal_error(error, source_text) {
+        saw_decode = true;
+        consider_override(&mut earliest, diagnostic, OverrideClass::Decode);
+    }
+    // A later ordinary unterminated quote is only a fallback. Format-spec
+    // newlines and empty fields are decode diagnostics and must keep winning.
+    let line_continuation = matches!(
+        &error.error,
+        parser::ParseErrorType::Lexical(parser::LexicalErrorType::LineContinuationError)
+    );
+    if !saw_decode
+        && !line_continuation
+        && let Some(diagnostic) = unterminated_string_error(source_text, mode)
+    {
+        consider_override(&mut earliest, diagnostic, OverrideClass::Lexer);
+    }
+    if earliest
+        .as_ref()
+        .is_none_or(|current| current.class != OverrideClass::Lexer)
+        && let Some(diagnostic) = invalid_legacy_statement_error(source_text)
+    {
+        consider_override(&mut earliest, diagnostic, OverrideClass::Print);
+    }
+    if !saw_decode
+        && earliest
+            .as_ref()
+            .is_none_or(|current| current.class == OverrideClass::Print)
+        && let Some(bracket) = bracket.filter(|bracket| bracket.unclosed)
+    {
+        consider_ranked(
+            &mut earliest,
+            bracket.diagnostic,
+            true,
+            OverrideClass::Lexer,
+        );
+    }
+    if let Some(override_diag) = earliest {
         return Some(
-            NormalizedParseDiagnostic::other(source_file, bracket.diagnostic)
-                .with_unclosed_bracket(bracket.unclosed),
+            NormalizedParseDiagnostic::other(source_file, override_diag.diagnostic)
+                .with_unclosed_bracket(override_diag.unclosed_bracket),
         );
     }
 
@@ -293,7 +402,9 @@ fn cpython_parse_diagnostic_override(
         }
         let loc = source_location(source_file, error.location.start() + TextSize::from(1));
         return Some(NormalizedParseDiagnostic::new(
-            error.error.clone(),
+            parser::ParseErrorType::OtherError(
+                "unexpected character after line continuation character".to_owned(),
+            ),
             loc,
             loc,
         ));
@@ -591,7 +702,11 @@ fn invalid_radix_literal_error(
     let mut has_digit = false;
     loop {
         let Some(&byte) = bytes.get(index) else {
-            return Some((format!("invalid {kind} literal"), start + 1));
+            return if has_digit {
+                None
+            } else {
+                Some((format!("invalid {kind} literal"), start + 1))
+            };
         };
         if byte == b'_' {
             let Some(&next) = bytes.get(index + 1) else {
@@ -5876,6 +5991,7 @@ fn expected_opening_bracket(closing: char) -> char {
 
 /// A bracket diagnostic, and whether it is an opener that was never closed. The caller needs
 /// that apart from the message because ruff reports the unclosed case as an EOF error.
+#[derive(Clone)]
 struct BracketError {
     diagnostic: CpythonDiagnostic,
     unclosed: bool,
@@ -5932,6 +6048,24 @@ fn bracket_syntax_error(source: &str) -> Option<BracketError> {
             continue;
         }
 
+        if ch == '\\' {
+            match chars.get(index + 1).map(|(_, next)| *next) {
+                Some('\n' | '\r') => {
+                    escape_next = true;
+                    index += 1;
+                    continue;
+                }
+                Some(_) => {
+                    index += 2;
+                    continue;
+                }
+                None => {
+                    index += 1;
+                    continue;
+                }
+            }
+        }
+
         if ch == '\'' || ch == '"' {
             is_raw_string = false;
             for look_back in 1..=2.min(index) {
@@ -7496,6 +7630,49 @@ mod tests {
             ("fu''", "'u' and 'f' prefixes are incompatible"),
             ("fb''", "'b' and 'f' prefixes are incompatible"),
             ("ufr''", "'u' and 'r' prefixes are incompatible"),
+            (
+                "(]\nbu'x'",
+                "closing parenthesis ']' does not match opening parenthesis '('",
+            ),
+            ("0x\nbu'x'", "invalid hexadecimal literal"),
+            ("(0x", "invalid hexadecimal literal"),
+            ("print x; 0x", "invalid hexadecimal literal"),
+            ("exec x; 0x", "invalid hexadecimal literal"),
+            (
+                "print x; 0x1",
+                "Missing parentheses in call to 'print'. Did you mean print(...)?",
+            ),
+            (
+                "print x; (",
+                "Missing parentheses in call to 'print'. Did you mean print(...)?",
+            ),
+            ("print x; )", "unmatched ')'"),
+            (
+                "( '\\N'",
+                "(unicode error) 'unicodeescape' codec can't decode bytes in position 0-1: malformed \\N character escape",
+            ),
+            ("(print x", "'(' was never closed"),
+            (
+                "(print x; '\\N'",
+                "Missing parentheses in call to 'print'. Did you mean print(...)?",
+            ),
+            ("f'{x'; '", "f-string: expecting '}'"),
+            ("f'{x'; 0x", "f-string: expecting '}'"),
+            (
+                "print x; f'{x'; 0x",
+                "Missing parentheses in call to 'print'. Did you mean print(...)?",
+            ),
+            (
+                concat!("f'{1:", "d\n}'"),
+                "f-string: newlines are not allowed in format specifiers",
+            ),
+            ("f'{\n}'", "f-string: valid expression required before '}'"),
+            (
+                "f'''\n{\n# only a comment\n}'''",
+                "f-string: valid expression required before '}'",
+            ),
+            ("{\\'a\\'}", "unexpected character after line continuation"),
+            ("\"\\\n\"(1 for c in I,\\\n\\", "'(' was never closed"),
             (
                 r"'\N'",
                 "(unicode error) 'unicodeescape' codec can't decode bytes in position 0-1: malformed \\N character escape",
@@ -7514,6 +7691,23 @@ mod tests {
         }
     }
 
+    #[test]
+    fn unclosed_fstring_field_keeps_the_unclosed_bracket_flag() {
+        let err = compile("f'{", Mode::Eval, "<interp>", CompileOpts::default())
+            .expect_err("should not compile");
+        let crate::CompileError::Parse(parse) = err else {
+            panic!("expected a parse error, got {err}");
+        };
+        assert!(
+            parse.is_unclosed_bracket,
+            "unclosed f-string field must stay incomplete, got {parse}"
+        );
+        assert!(
+            parse.to_string().contains("'{' was never closed"),
+            "got {parse}"
+        );
+    }
+
     #[test]
     fn interpolated_literals_do_not_take_the_escaped_quote_hint() {
         // Parser/lexer/lexer.c offers "perhaps you escaped the end quote?" from its plain-string
 
@@ -16,19 +16,19 @@ ssl = ["dep:rustls", "dep:rustls-pemfile", "dep:rustls-webpki", "dep:x509-parser
 rustpython-wtf8 = { workspace = true }
 
 bitflags = { workspace = true }
+der = { workspace = true, optional = true }
 getrandom = { workspace = true }
 libc = { workspace = true }
 num-traits = { workspace = true }
 parking_lot = { workspace = true }
 paste = { workspace = true }
-widestring = { workspace = true }
+pkcs8 = { workspace = true, features = ["encryption", "pkcs5", "pem"], optional = true }
 rustls = { workspace = true, default-features = false, features = ["std", "tls12"], optional = true }
 rustls-pemfile = { workspace = true, optional = true }
 rustls-webpki = { workspace = true, optional = true }
-x509-parser = { workspace = true, optional = true }
-der = { workspace = true, optional = true }
-pkcs8 = { workspace = true, features = ["encryption", "pkcs5", "pem"], optional = true }
 sha2 = { workspace = true, optional = true }
+widestring = { workspace = true }
+x509-parser = { workspace = true, optional = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }
@@ -39,6 +39,11 @@ rustix = { workspace = true }
 [target.'cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))'.dependencies]
 num_cpus = "1.17.0"
 
+# rustls-pki-types::UnixTime::now is gated off wasm32-unknown-unknown unless
+# the `web` feature is on. Browser rustls and Charon/LLBC both need it.
+[target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
+rustls-pki-types = { version = "1", default-features = false, features = ["alloc", "std", "web"] }
+
 [target.'cfg(not(any(target_os = "ios", target_os = "android", target_os = "windows", target_arch = "wasm32", target_os = "redox")))'.dependencies]
 mac_address = { workspace = true }
 
@@ -76,9 +81,11 @@ windows-sys = { workspace = true, features = [
     "Win32_Security",
     "Win32_Security_Authorization",
     "Win32_Storage_FileSystem",
+    "Win32_System_Com",
     "Win32_System_Console",
     "Win32_System_Diagnostics_Debug",
     "Win32_System_Environment",
+    "Win32_System_Ole",
     "Win32_System_IO",
     "Win32_System_Ioctl",
     "Win32_System_JobObjects",
@@ -106,3 +113,8 @@ cc = "1"
 
 [lints]
 workspace = true
+
+[package.metadata.cargo-shear]
+# Feature-unification only: enables rustls-pki-types `web` so UnixTime::now
+# exists on wasm32-unknown-unknown. No rust source imports this crate.
+ignored = ["rustls-pki-types"]