Clean up overlays and remove obsolete dependencies

overlays/default.nix

@@ -17,7 +17,7 @@
 
   patches = import ./patches;
   test-exclusions = import ./test-exclusions.nix;
-  x86-64-v3-workarounds = import ./x86-64-v3-workarounds.nix;
+  # x86-64-v3-workarounds = import ./x86-64-v3-workarounds.nix;
 
   python-env = final: _prev: {
     my_python = final.python314.withPackages (

overlays/patches/README.md

@@ -0,0 +1,46 @@
+# Package patches
+
+Each package follows the [GnuTLS layout](gnutls/README.md):
+
+- `default.nix` applies the patch through the package overlay.
+- A descriptive `.patch` file contains the standalone upstream source change.
+- `README.md` explains the problem, scope, reproduction, upstream status,
+  Nix integration, and recorded validation limits.
+- Companion `verify-*` tools live beside the patch when needed; otherwise
+  the README gives commands for the package's existing tests.
+
+Keep package-specific evidence in its directory. Patch headers explain the
+change independently of Nix, and `default.nix` preserves existing patches.
+
+| Package | Repair |
+| --- | --- |
+| [Abseil](abseil/README.md) | Public BMI2 header in Electron, Deno, and Signal's vendored copies |
+| [Backrefs](backrefs/README.md) | Match the regex timeout's CPU clock |
+| [GnuTLS](gnutls/README.md) | Wait for the UDP server socket before connecting |
+| [Jupyter Server](jupyter-server/README.md) | Exercise the correct shared future during reconnect |
+| [Prometheus](prometheus/README.md) | Complete parsing before inspecting the test editor state |
+| [pytest-xdist](pytest-xdist/README.md) | Check worker replacements despite concurrent crashes |
+| [SciPy](scipy/README.md) | Account for floating-point rounding in STFT tests |
+| [Sentry SDK](sentry-sdk/README.md) | Isolate SDK thread mocks from Python's threading module |
+| [Torchaudio](torchaudio/README.md) | Compare pitch-shift batches at appropriate precision |
+| [TorchCodec](torchcodec/README.md) | Match the reference MP3 encoder's sample format |
+
+## Local NixOS integration
+
+[`../default.nix`](../default.nix) imports this directory's
+[`default.nix`](default.nix), which wires each package's override into the
+package set. Abseil repairs several vendored copies and is gated on
+`x86-64-v3`; Prometheus patches its separate assets derivation; Python
+packages use `pythonPackagesExtensions`.
+
+[`../test-exclusions.nix`](../test-exclusions.nix) retains only pytest-xdist's
+outer-worker limit and inner-worker startup allowance. It adds no skipped
+tests. Existing nixpkgs exclusions remain separate from these repairs.
+
+The test-exclusion review used Python 3.14.7 and the pinned x86-64-v3 package
+set. Host-flake evaluation verified patch wiring, Python install checks,
+removal of the local skips, and Prometheus's reference to the patched assets.
+Jupyter and Sentry package tests used the preceding dependency set with the
+new package patch to avoid unrelated rebuilds after pytest-xdist changed.
+No complete NixOS rebuild was performed. Individual READMEs distinguish
+package builds, focused tests, and checks that have not been run.

overlays/patches/abseil/README.md

@@ -0,0 +1,59 @@
+# Abseil BMI2 public header
+
+Vendored Abseil includes `bmi2intrin.h` directly when `__BMI2__` is enabled.
+Compilers reject that internal header without the umbrella-header setup.
+`bmi2-public-header.patch` includes `immintrin.h` instead, allowing builds
+that enable BMI2 through `-march=x86-64-v3`.
+
+## Scope and behavior
+
+The patch changes one include in
+`third_party/abseil-cpp/absl/container/internal/raw_hash_set.h`.
+`default.nix` applies it to Electron 43's unwrapped package, Deno's
+`librusty_v8`, and Signal's WebRTC dependency. It also supplies the patched
+Electron package to Signal. These overrides apply only to `x86-64-v3`.
+
+The shared file path is relative to each vendoring project's source root,
+not the root of a standalone Abseil checkout. No hash-table algorithm or
+test exclusion changes.
+
+## Reproduction and focused checks
+
+From this directory, check and apply the patch to each vendored source tree:
+
+```sh
+patch --dry-run --fuzz=0 -d /path/to/vendor-source -p1 < bmi2-public-header.patch
+patch --fuzz=0 -d /path/to/vendor-source -p1 < bmi2-public-header.patch
+```
+
+A small compiler check isolates the header requirement. With GCC or Clang
+on x86-64, compile `#include <bmi2intrin.h>` using `-march=x86-64-v3`; the
+compiler rejects the direct include. Changing it to `#include <immintrin.h>`
+should compile. The full consumer builds below check integration with their
+actual toolchains.
+
+## Upstream status
+
+Abseil addressed this issue through
+[PR #2071](https://github.com/abseil/abseil-cpp/pull/2071), imported by its
+upstream workflow. That change uses `x86gprintrin.h`; this local variant uses
+the public `immintrin.h` umbrella header for the vendored toolchains.
+Keep the workaround until all three bundled copies include a compatible fix.
+This file is a local adaptation, not a verbatim copy of the upstream diff.
+
+## Local NixOS integration and build results
+
+[`../default.nix`](../default.nix) merges this directory's overlay fragment
+because it repairs multiple packages. From the repository root, the consumer
+build commands are:
+
+```sh
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.deno
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.electron_43
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.signal-desktop
+```
+
+The earlier extraction checked the vendored header snapshots and evaluated
+all three patch attachments. Those records do not establish successful full
+consumer rebuilds. No new compiler or consumer build was run for the layout
+change; the patch and override are unchanged.

overlays/patches/default.nix

@@ -2,10 +2,13 @@ _final: prev:
 (import ./abseil { inherit prev; })
 // {
   gnutls = import ./gnutls { inherit (prev) gnutls; };
+  prometheus = import ./prometheus { inherit (prev) prometheus; };
 
   pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [
     (_pythonFinal: pythonPrev: {
-      scipy = import ./scipy { inherit (pythonPrev) scipy; };
+      backrefs = import ./backrefs { inherit (pythonPrev) backrefs; };
+      pytest-xdist = import ./pytest-xdist { inherit (pythonPrev) pytest-xdist; };
+      sentry-sdk = import ./sentry-sdk { inherit (pythonPrev) sentry-sdk; };
       torchcodec = import ./torchcodec { inherit (pythonPrev) torchcodec; };
     })
   ];

overlays/patches/prometheus/README.md

@@ -0,0 +1,66 @@
+# Prometheus complete test parsing
+
+CodeMirror gives editor-state creation a 20 ms synchronous parsing budget.
+The shared `createEditorState()` test helper can therefore return an
+incomplete syntax tree when the process is descheduled. The completion and
+vector-matching tests immediately inspect that tree.
+
+## Scope and behavior
+
+`complete-test-parsing.patch` changes only
+`module/codemirror-promql/src/test/utils-test.ts` inside `web/ui`. It completes
+the small test expression with `ensureSyntaxTree(..., Infinity)` and publishes
+the completed parse through an empty transaction so `syntaxTree(state)` sees
+it. Failure to obtain a tree raises an error.
+
+The original assertions remain enabled, including `autocomplete topk params 2`
+and `foo * on(test,blub) bar`. The unlimited budget applies to the test helper;
+production editor parsing budgets are unchanged.
+
+## Reproduction and focused checks
+
+Use a disposable Prometheus 3.14.0 checkout. The patch root is `web/ui`, matching
+the Nix assets derivation. From this directory:
+
+```sh
+patch --fuzz=0 -d /path/to/prometheus/web/ui -p1 < complete-test-parsing.patch
+cd /path/to/prometheus/web/ui
+pnpm install --frozen-lockfile
+pnpm --filter @prometheus-io/lezer-promql build
+pnpm --filter @prometheus-io/codemirror-promql test
+```
+
+To force the scheduling condition, temporarily append this clock to
+`module/codemirror-promql/setupJest.cjs` in the disposable checkout:
+
+```js
+let parseClock = 0;
+Date.now = () => (parseClock += 25);
+```
+
+Each clock read crosses the editor's initial parsing budget. Against the
+original helper, the hybrid and vector suites have 186 failures, including
+both locally excluded cases. With the patch, all 386 CodeMirror tests pass
+under that same clock. Remove the injected clock before normal builds.
+
+## Upstream status
+
+This is a standalone test-helper patch for Prometheus 3.14.0. No upstream
+submission was made during this work. Recheck the helper when updating
+Prometheus or CodeMirror, including how an ensured parse becomes visible
+through the editor state.
+
+## Local NixOS integration and build results
+
+[`../default.nix`](../default.nix) loads `default.nix`, which patches the
+separate assets derivation. It updates both `passthru.assets` and the main
+Prometheus build's reference to those assets. From the repository root:
+
+```sh
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.prometheus.assets
+```
+
+The full x86-64-v3 assets build passed with the normal clock, including the
+CodeMirror and UI suites. Host-flake evaluation confirmed that the main
+Prometheus derivation refers to these patched assets. The Go server package
+was not rebuilt for this test-helper change.

overlays/patches/prometheus/complete-test-parsing.patch

@@ -0,0 +1,36 @@
+Subject: [PATCH] tests: finish parsing before inspecting editor state
+
+EditorState creation has a 20 ms parsing budget. A descheduled test can
+therefore observe an incomplete tree. Finish these small test documents
+without an interactive deadline and publish the result with a transaction.
+Keep the original completion and vector-matching assertions enabled.
+
+--- a/module/codemirror-promql/src/test/utils-test.ts
++++ b/module/codemirror-promql/src/test/utils-test.ts
+@@ -13,7 +13,7 @@
+ 
+ import { parser } from '@prometheus-io/lezer-promql';
+ import { EditorState } from '@codemirror/state';
+-import { LRLanguage } from '@codemirror/language';
++import { ensureSyntaxTree, LRLanguage } from '@codemirror/language';
+ import nock from 'nock';
+ import path from 'path';
+ import { fileURLToPath } from 'url';
+@@ -23,10 +23,16 @@
+ const __dirname = path.dirname(fileURLToPath(import.meta.url));
+ 
+ export function createEditorState(expr: string): EditorState {
+-  return EditorState.create({
++  const state = EditorState.create({
+     doc: expr,
+     extensions: lightPromQLSyntax,
+   });
++  // These tests need a complete tree, independent of the editor's time budget.
++  if (!ensureSyntaxTree(state, state.doc.length, Infinity)) {
++    throw new Error('Unable to parse the test expression');
++  }
++  // Publish the completed parse so syntaxTree(state) sees it too.
++  return state.update({}).state;
+ }
+ 
+ export function mockPrometheusServer(): void {

overlays/patches/prometheus/default.nix

@@ -0,0 +1,17 @@
+{ prometheus }:
+prometheus.overrideAttrs (
+  old:
+  let
+    assets = old.passthru.assets.overrideAttrs (assetsOld: {
+      patches = (assetsOld.patches or [ ]) ++ [ ./complete-test-parsing.patch ];
+    });
+  in
+  {
+    postPatch = builtins.replaceStrings [ "${old.passthru.assets}" ] [ "${assets}" ] (
+      builtins.unsafeDiscardStringContext old.postPatch
+    );
+    passthru = old.passthru // {
+      inherit assets;
+    };
+  }
+)

overlays/patches/pytest-xdist/README.md

@@ -0,0 +1,67 @@
+# pytest-xdist concurrent worker crashes
+
+With two workers and a restart limit of three, the fourth worker crash
+requests shutdown while another test can still be running. That test may
+also crash. The original queued-work test requires exactly four failures,
+even though five failures can occur without exceeding the replacement limit.
+
+## Scope and behavior
+
+`concurrent-worker-crashes.patch` changes the assertions in
+`TestNodeFailure.test_max_worker_restart_tests_queued` in
+`testing/acceptance_test.py`. It requires exactly three replacements, four or
+five failed tests, the failed-tests exit status, the limit message, and no
+internal error. It retains the two-worker workload and ten queued tests.
+
+The existing nixpkgs pytest-9 compatibility patches remain in place.
+Production scheduling and worker-restart behavior are unchanged.
+
+## Reproduction and focused checks
+
+Use a disposable pytest-xdist 3.8.0 checkout with its test dependencies and
+the nixpkgs pytest-9 compatibility patches where required. From this directory:
+
+```sh
+patch --fuzz=0 -d /path/to/pytest-xdist -p1 < concurrent-worker-crashes.patch
+cd /path/to/pytest-xdist
+python -m pytest testing/acceptance_test.py \
+  -k test_max_worker_restart_tests_queued -q
+```
+
+Twenty unmodified runs passed during the review. To force the failing
+schedule, modify the generated crashing test in a disposable checkout to
+accept `worker_id`: make `gw3` wait for a marker created by `gw4`, and make
+`gw4` pause 0.1 seconds after creating the marker. Then both have in-flight
+tests when shutdown starts. Bound the marker wait so a reproduction failure
+cannot hang the suite. The original assertion fails on five reported
+failures; the patched test passes.
+
+## Remaining resource settings
+
+[`../../test-exclusions.nix`](../../test-exclusions.nix) runs the outer suite
+with one worker and sets the inner-worker wait to 60 seconds. These settings
+limit nested process pools and allow worker startup on loaded builders.
+
+A separate reproduction inserts an 11-second `pytest_sessionstart` delay
+into the child created by `test_basic_collect_and_runtests` in
+`testing/test_remote.py`. The original 10-second channel wait fails; the
+60-second wait passes. This is a worker-startup bound, not a product deadline.
+
+## Upstream status
+
+This is a standalone test patch for pytest-xdist 3.8.0. No upstream submission
+was made during this work. Recheck the allowed in-flight failures and
+replacement count when updating the scheduler or shutdown behavior.
+
+## Local NixOS integration and build results
+
+[`../default.nix`](../default.nix) loads `default.nix` through
+`pythonPackagesExtensions`. From the repository root:
+
+```sh
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.python314Packages.pytest-xdist
+```
+
+The patched x86-64-v3 package passed 185 tests, with 6 existing skips and
+10 expected failures. The forced concurrent-crash reproduction passed after
+the fix, and the focused test passed again after formatting the assertion.

overlays/patches/pytest-xdist/concurrent-worker-crashes.patch

@@ -0,0 +1,29 @@
+Subject: [PATCH] tests: count replacements when checking the worker restart limit
+
+With two workers, another in-flight test may crash after the fourth
+crash requests shutdown. Either four or five failed tests is valid.
+Require exactly three replacements and the failed-tests exit status,
+while preserving the queued-work and no-internal-error assertions.
+
+--- a/testing/acceptance_test.py
++++ b/testing/acceptance_test.py
+@@ -1011,9 +1011,18 @@
+                 "worker*crashed while running*",
+                 "worker*crashed while running*",
+                 "* xdist: maximum crashed workers reached: 3 *",
+-                "* 4 failed in *",
+             ]
+         )
++        # A second in-flight test may crash after shutdown is requested.
++        # The restart limit constrains replacements, not concurrent failures.
++        replacements = sum(
++            line.startswith("replacing crashed worker ") for line in res.stdout.lines
++        )
++        assert replacements == 3
++        failed = res.parseoutcomes()["failed"]
++        assert failed in (4, 5)
++        res.assert_outcomes(failed=failed)
++        assert res.ret == pytest.ExitCode.TESTS_FAILED
+         assert "INTERNALERROR" not in res.stdout.str()
+ 
+     def test_max_worker_restart_die(self, pytester: pytest.Pytester) -> None:

overlays/patches/pytest-xdist/default.nix

@@ -0,0 +1,4 @@
+{ pytest-xdist }:
+pytest-xdist.overridePythonAttrs (old: {
+  patches = (old.patches or [ ]) ++ [ ./concurrent-worker-crashes.patch ];
+})

overlays/patches/scipy/default.nix

@@ -1,5 +0,0 @@
-{ scipy }:
-scipy.overridePythonAttrs (old: {
-  # Keep the STFT tests enabled with tolerances for x86-64-v3 rounding.
-  patches = (old.patches or [ ]) ++ [ ./stft-test-tolerances.patch ];
-})

overlays/patches/scipy/stft-test-tolerances.patch

@@ -1,51 +0,0 @@
-Subject: [PATCH] signal: allow floating-point rounding in STFT tests
-
-Keep the STFT tests enabled for x86-64-v3 builds. Allow two float32
-epsilons of relative error when comparing inverse-STFT implementations;
-float64 and the existing i686 override remain unchanged. Allow one
-float64 epsilon of absolute error in all three scaling round trips,
-which otherwise require exact zeros (observed residual: 4e-17 for a
-signal with amplitude 2).
-
-Upstream issue: https://github.com/scipy/scipy/issues/25488
-
---- a/scipy/signal/tests/_scipy_spectral_test_shim.py
-+++ b/scipy/signal/tests/_scipy_spectral_test_shim.py
-@@ -294,7 +294,7 @@
- 
-     # Adapted tolerances to account for resolution loss:
-     atol = np.finfo(x.dtype).resolution*2  # instead of default atol = 0
--    rtol = 1e-7  # default for np.allclose()
-+    rtol = max(1e-7, 2 * np.finfo(x.dtype).eps)
- 
-     # Relax atol on 32-Bit platforms a bit to pass CI tests.
-     #  - Not clear why there are discrepancies (in the FFT maybe?)
---- a/scipy/signal/tests/test_spectral.py
-+++ b/scipy/signal/tests/test_spectral.py
-@@ -2044,7 +2044,7 @@
- 
-         # Test round trip:
-         x1 = istft(Zs, boundary=True, scaling='spectrum')[1]
--        assert_allclose(x1, x)
-+        assert_allclose(x1, x, atol=np.finfo(x.dtype).eps)
- 
-         # For a Hann-windowed 256 sample length FFT, we expect a peak at
-         # frequency 64 (since it is 1/4 the length of X) with a height of 1
-@@ -2074,7 +2074,7 @@
- 
-         # Test round trip:
-         x1 = istft(Zp, input_onesided=False, boundary=True, scaling='psd')[1]
--        assert_allclose(x1, x)
-+        assert_allclose(x1, x, atol=np.finfo(x.dtype).eps)
- 
-         # The power of the one-sided psd-scaled STFT can be determined
-         # analogously (note that the two sides are not of equal shape):
-@@ -2094,7 +2094,7 @@
- 
-         # Test round trip:
-         x1 = istft(Zp0, input_onesided=True, boundary=True, scaling='psd')[1]
--        assert_allclose(x1, x)
-+        assert_allclose(x1, x, atol=np.finfo(x.dtype).eps)
- 
- 
- class TestSampledSpectralRepresentations:

overlays/patches/sentry-sdk/README.md

@@ -0,0 +1,58 @@
+# Sentry SDK thread-metadata test isolation
+
+The fallback tests globally mock `threading.current_thread` while a worker
+is running. Python 3.14's `Thread.join()` also calls that function. A one-use
+mock can therefore be consumed by the wrong caller or raise `StopIteration`
+when the main thread joins the worker.
+
+## Scope and behavior
+
+`isolate-threading-mocks.patch` changes three neighboring thread-metadata
+tests in `tests/test_utils.py`, including the formerly excluded
+`test_get_current_thread_meta_main_thread`.
+
+Each test replaces only `sentry_sdk.utils.threading`, wraps the real module
+for unmocked operations, and sets the SDK lookup's return value. The real
+`Thread.join()` continues using Python's unmodified `threading` module.
+The fallback-result assertions remain; SDK production code is unchanged.
+
+## Reproduction and focused checks
+
+Use a disposable Sentry SDK 2.66.0 checkout and its Python test dependencies.
+From this directory:
+
+```sh
+patch --fuzz=0 -d /path/to/sentry-python -p1 < isolate-threading-mocks.patch
+cd /path/to/sentry-python
+python -m pytest tests/test_utils.py -k get_current_thread_meta -q
+```
+
+To reproduce the race, hold the worker inside its mock just after
+`get_current_thread_meta()` returns, signal that point to the main thread,
+and call `Thread.join()` before releasing the worker. Use an independent
+bounded release so the patched join can finish. The original test raises
+`StopIteration` in `join`; the patched test passes under the same schedule.
+Perform this scheduling instrumentation only in a disposable checkout.
+
+## Upstream status
+
+This is a standalone test patch for Sentry SDK 2.66.0. No upstream submission
+was made during this work. Recheck mock isolation and Python threading
+behavior when upgrading the SDK or interpreter.
+
+## Local NixOS integration and build results
+
+[`../default.nix`](../default.nix) loads `default.nix` through
+`pythonPackagesExtensions`. From the repository root:
+
+```sh
+nix build --no-link -L .#nixosConfigurations.jeeves.pkgs.python314Packages.sentry-sdk
+```
+
+The patched package passed 2,356 tests with 116 existing skips on Python
+3.14.7. The controlled join reproduction failed before the fix and passed
+after it.
+
+That package build used the preceding dependency set with this patch to avoid
+unrelated rebuilds after pytest-xdist changed. The integrated host derivation
+was evaluated; a complete NixOS rebuild was not performed.

overlays/patches/sentry-sdk/default.nix

@@ -0,0 +1,4 @@
+{ sentry-sdk }:
+sentry-sdk.overridePythonAttrs (old: {
+  patches = (old.patches or [ ]) ++ [ ./isolate-threading-mocks.patch ];
+})

overlays/patches/sentry-sdk/isolate-threading-mocks.patch

@@ -0,0 +1,41 @@
+Subject: [PATCH] tests: isolate SDK thread lookup mocks from Python threading
+
+Thread.join also calls threading.current_thread on Python 3.14. A global
+single-use side effect can be consumed by join instead of the SDK, or
+raise StopIteration in join after the SDK consumes it. Patch the SDK's
+module binding and delegate unmocked operations to the real module.
+Apply the same isolation to the adjacent invalid-thread fallback tests.
+
+--- a/tests/test_utils.py
++++ b/tests/test_utils.py
+@@ -914,7 +914,8 @@
+     results = Queue(maxsize=1)
+ 
+     def target():
+-        with mock.patch("threading.current_thread", side_effect=["fake thread"]):
++        with mock.patch("sentry_sdk.utils.threading", wraps=threading) as sdk_threading:
++            sdk_threading.current_thread.return_value = "fake thread"
+             results.put(get_current_thread_meta())
+ 
+     thread = threading.Thread(target=target)
+@@ -930,7 +931,9 @@
+ 
+     def target():
+         # mock that somehow the current thread doesn't exist
+-        with mock.patch("threading.current_thread", side_effect=[None]):
++        # Keep the real threading module intact for concurrent Thread.join calls.
++        with mock.patch("sentry_sdk.utils.threading", wraps=threading) as sdk_threading:
++            sdk_threading.current_thread.return_value = None
+             results.put(get_current_thread_meta())
+ 
+     main_thread = threading.main_thread()
+@@ -945,7 +948,8 @@
+     results = Queue(maxsize=1)
+ 
+     def target():
+-        with mock.patch("threading.current_thread", return_value="fake thread"):
++        with mock.patch("sentry_sdk.utils.threading", wraps=threading) as sdk_threading:
++            sdk_threading.current_thread.return_value = "fake thread"
+             results.put(get_current_thread_meta())
+ 
+     main_thread = threading.main_thread()

overlays/test-exclusions.nix

@@ -1,51 +1,15 @@
-# Test exclusions for the locally rebuilt x86-64-v3 package set.
+# Test resource settings for the locally rebuilt x86-64-v3 package set.
 #
 # Selecting x86-64-v3 changes every affected derivation, so the normal
 # nixpkgs binary cache cannot be used and upstream test suites run locally.
 # The jeeves builder uses /tmp/nix-builds so filesystem tests run on tmpfs
 # instead of ZFS with normalization=formD and utf8only=on; those tests remain
-# enabled. The remaining workarounds cover UDP readiness, resource-sensitive
+# enabled. This overlay no longer excludes any tests. The remaining settings
-# parser and nested-worker races, and mismatched timeout clocks, plus
+# bound nested worker concurrency and allow time for worker startup under load.
-# architecture-dependent floating-point differences whose risk we accept for
+# Test repairs and their validation are indexed in patches/README.md.
-# our workloads. Keep these exceptions visible until their causes are fixed.
 _final: prev: {
-  prometheus = prev.prometheus.overrideAttrs (
-    old:
-    let
-      assets = old.passthru.assets.overrideAttrs (assetsOld: {
-        # CodeMirror's bounded synchronous parser can return an incomplete tree
-        # when these cases run on a heavily loaded builder.
-        postPatch = (assetsOld.postPatch or "") + ''
-          substituteInPlace module/codemirror-promql/src/complete/hybrid.test.ts \
-            --replace-fail "it(value.title, () => {" \
-            "(value.title === 'autocomplete topk params 2' ? it.skip : it)(value.title, () => {"
-          substituteInPlace module/codemirror-promql/src/parser/vector.test.ts \
-            --replace-fail "it(value.binaryExpr, () => {" \
-            "(value.binaryExpr === 'foo * on(test,blub) bar' ? it.skip : it)(value.binaryExpr, () => {"
-        '';
-      });
-    in
-    {
-      postPatch = builtins.replaceStrings [ "${old.passthru.assets}" ] [ "${assets}" ] (
-        builtins.unsafeDiscardStringContext old.postPatch
-      );
-      passthru = old.passthru // {
-        inherit assets;
-      };
-    }
-  );
-
   pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [
     (_pythonFinal: pythonPrev: {
-      backrefs = pythonPrev.backrefs.overridePythonAttrs (old: {
-        # regex measures its timeout in process CPU time, while this test used
-        # wall time and could miss the timeout when a busy builder descheduled it.
-        postPatch = (old.postPatch or "") + ''
-          substituteInPlace tests/test_bregex.py \
-            --replace-fail "time.time()" "time.process_time()"
-        '';
-      });
-
       pytest-xdist = pythonPrev.pytest-xdist.overridePythonAttrs (old: {
         # The suite exercises its own worker pools. Run the outer suite with one
         # worker and allow inner workers more time on heavily loaded builders.
@@ -56,60 +20,8 @@ _final: prev: {
         preCheck = builtins.replaceStrings [ "--numprocesses=$NIX_BUILD_CORES" ] [ "--numprocesses=1" ] (
           old.preCheck or ""
         );
-        # This test deliberately crashes workers past the restart limit and
-        # races while checking which replacement message was emitted.
-        disabledTests = (old.disabledTests or [ ]) ++ [
-          "test_max_worker_restart_tests_queued"
-        ];
       });
 
-      jupyter-server = pythonPrev.jupyter-server.overridePythonAttrs (old: {
-        # The kernel reply arrived after the one-second outer deadline when the
-        # builder was heavily loaded. Keep the regression test but allow it the
-        # same margin as the other resource-sensitive tests.
-        postPatch = (old.postPatch or "") + ''
-          substituteInPlace tests/services/kernels/test_connection.py \
-            --replace-fail \
-            "await asyncio.wait_for(asyncio.wrap_future(conn2.request_kernel_info()), timeout=1.0)" \
-            "await asyncio.wait_for(asyncio.wrap_future(conn2.request_kernel_info()), timeout=10.0)"
-        '';
-      });
-
-      sentry-sdk = pythonPrev.sentry-sdk.overridePythonAttrs (old: {
-        # This test globally mocks threading.current_thread while another
-        # thread is running. On Python 3.14, Thread.join can race with that
-        # mock and exhaust its single side effect before the worker removes it.
-        disabledTests = (old.disabledTests or [ ]) ++ [
-          "test_get_current_thread_meta_main_thread"
-        ];
-      });
-
-      torchaudio = pythonPrev.torchaudio.overridePythonAttrs (old: {
-        # x86-64-v3 pitch shifting produces batch-versus-single-item numerical
-        # differences up to 2.9e-6. We accept that audio-precision risk for our
-        # workloads.
-        disabledTests = (old.disabledTests or [ ]) ++ [
-          "test_batch_pitch_shift"
-        ];
-      });
-
-      torchcodec = pythonPrev.torchcodec.overridePythonAttrs (old: {
-        # For these 8 kHz MP3 cases, the x86-64-v3 API and CLI codec paths
-        # differ in 0.8% of decoded samples. Retain the original tolerance for
-        # 99% of samples and accept the localized audio-precision risk.
-        postPatch = (old.postPatch or "") + ''
-          substituteInPlace test/test_encoders.py \
-            --replace-fail \
-            'if sys.platform == "darwin":' \
-            'if sys.platform == "darwin" or (
-                format == "mp3"
-                and sample_rate == 8_000
-                and asset is SINE_MONO_S32
-                and bit_rate in (None, 0)
-                and num_channels in (None, 1)
-            ):'
-        '';
-      });
     })
   ];
 }