helloadhavan/github_issues huggingface dataset:
Repository: electron/electron
Pull request: fix: validate USB device selection against filtered device list

Backport of #50002

See that PR for details.


Notes: none

Changed files:
filename: shell/browser/usb/usb_chooser_controller.cc
patch: @@ -68,6 +68,7 @@ gin::WeakCell<api::Session>* UsbChooserController::GetSession() {
 void UsbChooserController::OnDeviceAdded(
     const device::mojom::UsbDeviceInfo& device_info) {
   if (DisplayDevice(device_info)) {
+    devices_.push_back(device_info.Clone());
     gin::WeakCell<api::Session>* session = GetSession();
     if (session && session->Get()) {
       session->Get()->Emit("usb-device-added", device_info.Clone(),
@@ -78,6 +79,9 @@ void UsbChooserController::OnDeviceAdded(
 
 void UsbChooserController::OnDeviceRemoved(
     const device::mojom::UsbDeviceInfo& device_info) {
+  std::erase_if(devices_, [&device_info](const auto& device) {
+    return device->guid == device_info.guid;
+  });
   gin::WeakCell<api::Session>* session = GetSession();
   if (session && session->Get()) {
     session->Get()->Emit("usb-device-removed", device_info.Clone(),
@@ -90,9 +94,11 @@ void UsbChooserController::OnDeviceChosen(gin::Arguments* args) {
   if (!args->GetNext(&device_id) || device_id.empty()) {
     RunCallback(/*device_info=*/nullptr);
   } else {
-    auto* device_info = chooser_context_->GetDeviceInfo(device_id);
-    if (device_info) {
-      RunCallback(device_info->Clone());
+    const auto it = std::ranges::find_if(
+        devices_,
+        [&device_id](const auto& device) { return device->guid == device_id; });
+    if (it != devices_.end()) {
+      RunCallback((*it)->Clone());
     } else {
       util::EmitWarning(
           base::StrCat({"The device id ", device_id, " was not found."}),
@@ -127,6 +133,11 @@ void UsbChooserController::GotUsbDeviceList(
       return !DisplayDevice(*device_info);
     });
 
+    devices_.clear();
+    for (const auto& device : devices) {
+      devices_.push_back(device->Clone());
+    }
+
     v8::Local<v8::Object> details = gin::DataObjectBuilder(isolate)
                                         .Set("deviceList", devices)
                                         .Set("frame", rfh)

filename: shell/browser/usb/usb_chooser_controller.h
patch: @@ -5,6 +5,7 @@
 #ifndef ELECTRON_SHELL_BROWSER_USB_USB_CHOOSER_CONTROLLER_H_
 #define ELECTRON_SHELL_BROWSER_USB_USB_CHOOSER_CONTROLLER_H_
 
+#include <string>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
@@ -75,6 +76,9 @@ class UsbChooserController final : private UsbChooserContext::DeviceObserver,
 
   base::WeakPtr<ElectronUsbDelegate> usb_delegate_;
 
+  // Filtered list of devices that passed DisplayDevice()
+  std::vector<device::mojom::UsbDeviceInfoPtr> devices_;
+
   content::GlobalRenderFrameHostId render_frame_host_id_;
 
   base::WeakPtrFactory<UsbChooserController> weak_factory_{this};
Repository: huggingface/transformers
Pull request: Remove unused dependencies

# What does this PR do?

removes two unused dependencies.

Changed files:
filename: setup.py
patch: @@ -78,7 +78,6 @@
     "codecarbon>=2.8.1",
     "datasets>=2.15.0",  # We need either this pin or pyarrow<21.0.0
     "deepspeed>=0.9.3",
-    "diffusers",
     "dill<0.3.5",
     "evaluate>=0.4.6",
     "faiss-cpu",
@@ -88,7 +87,6 @@
     "GitPython<3.1.19",
     "hf-doc-builder>=0.3.0",
     "huggingface-hub>=1.3.0,<2.0",
-    "importlib_metadata",
     "ipadic>=1.0.0,<2.0",
     "jinja2>=3.1.0",
     "jmespath>=1.0.1",

filename: src/transformers/dependency_versions_table.py
patch: @@ -10,7 +10,6 @@
     "codecarbon": "codecarbon>=2.8.1",
     "datasets": "datasets>=2.15.0",
     "deepspeed": "deepspeed>=0.9.3",
-    "diffusers": "diffusers",
     "dill": "dill<0.3.5",
     "evaluate": "evaluate>=0.4.6",
     "faiss-cpu": "faiss-cpu",
@@ -20,7 +19,6 @@
     "GitPython": "GitPython<3.1.19",
     "hf-doc-builder": "hf-doc-builder>=0.3.0",
     "huggingface-hub": "huggingface-hub>=1.3.0,<2.0",
-    "importlib_metadata": "importlib_metadata",
     "ipadic": "ipadic>=1.0.0,<2.0",
     "jinja2": "jinja2>=3.1.0",
     "jmespath": "jmespath>=1.0.1",

filename: src/transformers/integrations/deepspeed.py
patch: @@ -16,7 +16,7 @@
 """
 
 import copy
-import importlib.metadata as importlib_metadata
+import importlib.metadata
 import importlib.util
 import weakref
 from functools import partialmethod
@@ -40,9 +40,9 @@ def is_deepspeed_available():
     # AND checking it has an author field in the metadata that is HuggingFace.
     if package_exists:
         try:
-            _ = importlib_metadata.metadata("deepspeed")
+            _ = importlib.metadata.metadata("deepspeed")
             return True
-        except importlib_metadata.PackageNotFoundError:
+        except importlib.metadata.PackageNotFoundError:
             return False
Repository: ollama/ollama
Pull request: parser: don't check the file type of safetensors to prevent false negatives.

The server tries to verify that the safetensor files are `application/octet-stream` by using `http.DetectContentType()` to determine the type of the contents of the file.  The safetensor [format](https://huggingface.co/docs/safetensors/en/index#format) is pretty simple, with the first 8 bytes being the length of the following header.  Unfortunately  the length of the header in model-00001-of-00050.safetensors is 256 bytes, or `00 01 00 00 00 00 00 00`, and this [matches](https://cs.opensource.google/go/go/+/refs/tags/go1.25.1:src/net/http/sniff.go;l=174) the [pattern](https://mimesniff.spec.whatwg.org/#matching-a-font-type-pattern:~:text=Embedded%20OpenType%20signature.-,00%2001%2000%2000,-FF%20FF%20FF) for `font/ttf`.  So the server is skipping the safetensor files because at least one of them looks like a font file.

Modify the test to skip checking the filetype for safetensors; keep the glob matching and prefix loading to verify the files are readable.

Fixes: #11897

Changed files:
filename: parser/parser.go
patch: @@ -246,7 +246,7 @@ func filesForModel(path string) ([]string, error) {
 		for _, match := range matches {
 			if ct, err := detectContentType(match); err != nil {
 				return nil, err
-			} else if ct != contentType {
+			} else if len(contentType) > 0 && ct != contentType {
 				return nil, fmt.Errorf("invalid content type: expected %s for %s", ct, match)
 			}
 		}
@@ -255,7 +255,8 @@ func filesForModel(path string) ([]string, error) {
 	}
 
 	var files []string
-	if st, _ := glob(filepath.Join(path, "*.safetensors"), "application/octet-stream"); len(st) > 0 {
+	// some safetensors files do not properly match "application/octet-stream", so skip checking their contentType
+	if st, _ := glob(filepath.Join(path, "*.safetensors"), ""); len(st) > 0 {
 		// safetensors files might be unresolved git lfs references; skip if they are
 		// covers model-x-of-y.safetensors, model.fp32-x-of-y.safetensors, model.safetensors
 		files = append(files, st...)
Repository: nodejs/node
Pull request: build: use path-ignore in GHA coverage-windows.yml

Use similar `paths-ignore` in other GHA jobs like `.github/workflows/test-macos.yml` to ignore certain changes that do not have effect on builds.

This allows changes to `configure.py`, `node.gyp`, or `src/inspector/node_protocol.pdl`, etc, to be tested on GHA windows.

For example, windows GHA was not triggered on https://github.com/nodejs/node/pull/61806.

Changed files:
filename: .github/workflows/coverage-windows.yml
patch: @@ -3,31 +3,55 @@ name: Coverage Windows
 on:
   pull_request:
     types: [opened, synchronize, reopened, ready_for_review]
-    paths:
-      - lib/**/*.js
-      - vcbuild.bat
-      - src/**/*.cc
-      - src/**/*.h
-      - test/**
-      - tools/gyp/**
-      - tools/test.py
-      - .github/workflows/coverage-windows.yml
-      - codecov.yml
-      - .nycrc
+    paths-ignore:
+      - '**.md'
+      - '**.nix'
+      - eslint.config.mjs
+      - '**/eslint.config_partial.mjs'
+      - android-configure
+      - android-configure.py
+      - android-patches/**
+      - benchmarks/**
+      - doc/**
+      - pyproject.yml
+      - tsconfig.json
+      - test/internet/**
+      - tools/actions/**
+      - tools/bootstrap/**
+      - tools/dep_updaters/**
+      - tools/doc/**
+      - tools/eslint-rules/**
+      - tools/eslint/**
+      - tools/lint-md/**
+      - typings/**
+      - .**
+      - '!.github/workflows/coverage-windows.yml'
   push:
     branches:
       - main
-    paths:
-      - lib/**/*.js
-      - vcbuild.bat
-      - src/**/*.cc
-      - src/**/*.h
-      - test/**
-      - tools/gyp/**
-      - tools/test.py
-      - .github/workflows/coverage-windows.yml
-      - codecov.yml
-      - .nycrc
+    paths-ignore:
+      - '**.md'
+      - '**.nix'
+      - eslint.config.mjs
+      - '**/eslint.config_partial.mjs'
+      - android-configure
+      - android-configure.py
+      - android-patches/**
+      - benchmarks/**
+      - doc/**
+      - pyproject.yml
+      - tsconfig.json
+      - test/internet/**
+      - tools/actions/**
+      - tools/bootstrap/**
+      - tools/dep_updaters/**
+      - tools/doc/**
+      - tools/eslint-rules/**
+      - tools/eslint/**
+      - tools/lint-md/**
+      - typings/**
+      - .**
+      - '!.github/workflows/coverage-windows.yml'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
Repository: rust-lang/rust
Pull request: Fix that `./x test --no-doc` actually keeps the same behaviour for backwards compatability

In https://github.com/rust-lang/rust/pull/153143 the `./x test --no-doc` flag was renamed to `--all-targets`.  I added a commit that keeps the `--no-doc` flag for backwards compatibility, but unfortunately I forgot to actually keep the behaviour the same, which is fixed by this PR.

r? @Kobzol 



Changed files:
filename: src/bootstrap/src/core/config/flags.rs
patch: @@ -570,16 +570,21 @@ impl Subcommand {
 
     pub fn test_target(&self) -> TestTarget {
         match *self {
-            Subcommand::Test { all_targets, doc, tests, .. }
-            | Subcommand::Miri { all_targets, doc, tests, .. } => match (all_targets, doc, tests) {
-                (true, true, _) | (true, _, true) | (_, true, true) => {
-                    panic!("You can only set one of `--all-targets`, `--doc` and `--tests`.")
+            Subcommand::Test { mut all_targets, doc, tests, no_doc, .. }
+            | Subcommand::Miri { mut all_targets, doc, tests, no_doc, .. } => {
+                // for backwards compatibility --no-doc keeps working
+                all_targets = all_targets || no_doc;
+
+                match (all_targets, doc, tests) {
+                    (true, true, _) | (true, _, true) | (_, true, true) => {
+                        panic!("You can only set one of `--all-targets`, `--doc` and `--tests`.")
+                    }
+                    (true, false, false) => TestTarget::AllTargets,
+                    (false, true, false) => TestTarget::DocOnly,
+                    (false, false, true) => TestTarget::Tests,
+                    (false, false, false) => TestTarget::Default,
                 }
-                (true, false, false) => TestTarget::AllTargets,
-                (false, true, false) => TestTarget::DocOnly,
-                (false, false, true) => TestTarget::Tests,
-                (false, false, false) => TestTarget::Default,
-            },
+            }
             _ => TestTarget::Default,
         }
     }
Repository: vercel/next.js
Pull request: Cleanup all stage promises on abort

Stacked on #89978

When the AbortSignal passed to the StagedRenderingController is aborted there is some logic to potentially abort any unresolved stage promises. Semantically anything we have a render with a stage controller that is aborted we must ensure no stage promises are left in a perpetually pending state.

Changed files:
filename: packages/next/src/server/app-render/staged-rendering.ts
patch: @@ -34,18 +34,15 @@ export class StagedRenderingController {
       abortSignal.addEventListener(
         'abort',
         () => {
+          // Reject all stage promises that haven't already been resolved.
+          // If a promise was already resolved via advanceStage, the reject
+          // is a no-op. The ignoreReject handler suppresses unhandled
+          // rejection warnings for promises that no one is awaiting.
           const { reason } = abortSignal
-          if (this.currentStage < RenderStage.Runtime) {
-            this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-            this.runtimeStagePromise.reject(reason)
-          }
-          if (
-            this.currentStage < RenderStage.Dynamic ||
-            this.currentStage === RenderStage.Abandoned
-          ) {
-            this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-            this.dynamicStagePromise.reject(reason)
-          }
+          this.runtimeStagePromise.promise.catch(ignoreReject)
+          this.runtimeStagePromise.reject(reason)
+          this.dynamicStagePromise.promise.catch(ignoreReject)
+          this.dynamicStagePromise.reject(reason)
         },
         { once: true }
       )
Repository: ollama/ollama
Pull request: llm: Avoid underflow in free memory logging

If a GPU's free memory is less than the reserved amount, we might get an underflow. Since it is an unsigned uint64, we print this as a large number rather than the more correct 0. This only affects logging, the actual layout code already handles this correctly.

Bug #12138

Changed files:
filename: llm/server.go
patch: @@ -678,8 +678,12 @@ func (s *ollamaServer) Load(ctx context.Context, gpus discover.GpuInfoList, requ
 
 	if !(len(gpus) == 1 && gpus[0].Library == "cpu") {
 		for _, gpu := range gpus {
+			available := gpu.FreeMemory - envconfig.GpuOverhead() - gpu.MinimumMemory
+			if gpu.FreeMemory < envconfig.GpuOverhead()+gpu.MinimumMemory {
+				available = 0
+			}
 			slog.Info("gpu memory", "id", gpu.ID,
-				"available", format.HumanBytes2(gpu.FreeMemory-envconfig.GpuOverhead()-gpu.MinimumMemory),
+				"available", format.HumanBytes2(available),
 				"free", format.HumanBytes2(gpu.FreeMemory),
 				"minimum", format.HumanBytes2(gpu.MinimumMemory),
 				"overhead", format.HumanBytes2(envconfig.GpuOverhead()))
Repository: huggingface/transformers
Pull request: Fix percentage formatting in help messages for gradient checkpointing, Liger Kernel, and empty cache steps

In https://github.com/huggingface/trl/pull/5112 a user reported that `trl sft --help` fails

It's because three inherited args from `TrainingArguments` (`torch_empty_cache_steps`, `gradient_checkpointing` and `use_liger_kernel`)help strings include bare `%` which break argparse formatting on Python 3.13. This PR fixes it.

Changed files:
filename: src/transformers/training_args.py
patch: @@ -896,7 +896,7 @@ class TrainingArguments:
     gradient_checkpointing: bool = field(
         default=False,
         metadata={
-            "help": "Enable gradient checkpointing to trade compute for memory. Reduces memory at the cost of ~20% slower training."
+            "help": "Enable gradient checkpointing to trade compute for memory. Reduces memory at the cost of ~20%% slower training."
         },
     )
     gradient_checkpointing_kwargs: dict[str, Any] | str | None = field(
@@ -925,7 +925,7 @@ class TrainingArguments:
     use_liger_kernel: bool = field(
         default=False,
         metadata={
-            "help": "Enable Liger Kernel optimizations. Increases throughput by ~20% and reduces memory by ~60%."
+            "help": "Enable Liger Kernel optimizations. Increases throughput by ~20%% and reduces memory by ~60%%."
         },
     )
     liger_kernel_config: dict[str, bool] | None = field(
@@ -951,7 +951,7 @@ class TrainingArguments:
     torch_empty_cache_steps: int | None = field(
         default=None,
         metadata={
-            "help": "Number of steps to wait before calling `torch.<device>.empty_cache()`. Helps avoid CUDA OOM at a cost of ~10% slower performance. If None, cache will not be emptied."
+            "help": "Number of steps to wait before calling `torch.<device>.empty_cache()`. Helps avoid CUDA OOM at a cost of ~10%% slower performance. If None, cache will not be emptied."
         },
     )
     auto_find_batch_size: bool = field(
Repository: facebook/react
Pull request: Reduce risk of leaving shipped Hooks as nullable on Dispatcher

By grepping for the feature flag you're now directed to the Dispatcher type. Members are only nullable if they're behind a feature flag so we should make them non-nullable when the flag ships. There's still the possibility that types are not updated when the flag is on everywhere but cleanup should flush it out.

Changed files:
filename: packages/react-reconciler/src/ReactInternalTypes.js
patch: @@ -394,7 +394,9 @@ export type Dispatcher = {
     create: () => (() => void) | void,
     deps: Array<mixed> | void | null,
   ): void,
+  // TODO: Non-nullable once `enableUseEffectEventHook` is on everywhere.
   useEffectEvent?: <Args, F: (...Array<Args>) => mixed>(callback: F) => F,
+  // TODO: Non-nullable once `enableUseResourceEffectHook` is on everywhere.
   useResourceEffect?: (
     create: () => mixed,
     createDeps: Array<mixed> | void | null,
@@ -429,7 +431,7 @@ export type Dispatcher = {
     getServerSnapshot?: () => T,
   ): T,
   useId(): string,
-  useCacheRefresh?: () => <T>(?() => T, ?T) => void,
+  useCacheRefresh: () => <T>(?() => T, ?T) => void,
   useMemoCache: (size: number) => Array<any>,
   useHostTransitionStatus: () => TransitionStatus,
   useOptimistic: <S, A>(

filename: packages/react-server/src/ReactFizzHooks.js
patch: @@ -835,6 +835,7 @@ export const HooksDispatcher: Dispatcher = supportsClientAPIs
       useFormState: useActionState,
       useHostTransitionStatus,
       useMemoCache,
+      useCacheRefresh,
     }
   : {
       readContext,
Repository: ollama/ollama
Pull request: harden uncaught exception registration

Some users (particularly x86 Macs) are hitting (intermittent) crashes during the dlopen of the ggml libraries.  There seems to be a race or intermittent failure mode where this initialization happens twice triggering the assert.  The C++ runtime is shared throughout the process, so each of these dlopen's is mutating the `std::terminate_handler`, and given this is ultimately just trying to wire up logging and a stack trace on catastrophic failures, the assert seems unnecessary.

Fixes #12072 

Changed files:
filename: llama/patches/0025-harden-uncaught-exception-registration.patch
patch: @@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Daniel Hiltgen <daniel@ollama.com>
+Date: Fri, 29 Aug 2025 16:53:08 -0700
+Subject: [PATCH] harden uncaught exception registration
+
+---
+ ggml/src/ggml.cpp | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/ggml/src/ggml.cpp b/ggml/src/ggml.cpp
+index 0d388d45..f5bcb446 100644
+--- a/ggml/src/ggml.cpp
++++ b/ggml/src/ggml.cpp
+@@ -19,8 +19,12 @@ static bool ggml_uncaught_exception_init = []{
+         return false;
+     }
+     const auto prev{std::get_terminate()};
+-    GGML_ASSERT(prev != ggml_uncaught_exception);
+-    previous_terminate_handler = prev;
++    // GGML_ASSERT(prev != ggml_uncaught_exception);
++    if (prev != ggml_uncaught_exception) {
++        previous_terminate_handler = prev;
++    } else {
++        GGML_LOG_WARN("%s double registration of ggml_uncaught_exception\n", __func__);
++    }
+     std::set_terminate(ggml_uncaught_exception);
+     return true;
+ }();

filename: ml/backend/ggml/ggml/src/ggml.cpp
patch: @@ -19,8 +19,12 @@ static bool ggml_uncaught_exception_init = []{
         return false;
     }
     const auto prev{std::get_terminate()};
-    GGML_ASSERT(prev != ggml_uncaught_exception);
-    previous_terminate_handler = prev;
+    // GGML_ASSERT(prev != ggml_uncaught_exception);
+    if (prev != ggml_uncaught_exception) {
+        previous_terminate_handler = prev;
+    } else {
+        GGML_LOG_WARN("%s double registration of ggml_uncaught_exception\n", __func__);
+    }
     std::set_terminate(ggml_uncaught_exception);
     return true;
 }();
Repository: ollama/ollama
Pull request: Revert "CI: switch back to x86 macos builder"

This reverts commit 9d071e6089319b37acf62bb739e3430dcb2ac0c3.


Turns out CI wasn't to blame - actual fix in #11585 

Changed files:
filename: .github/workflows/release.yaml
patch: @@ -23,7 +23,7 @@ jobs:
           echo GOFLAGS="'-ldflags=-w -s \"-X=github.com/ollama/ollama/version.Version=${GITHUB_REF_NAME#v}\" \"-X=github.com/ollama/ollama/server.mode=release\"'" >>$GITHUB_OUTPUT
 
   darwin-build:
-    runs-on: macos-13
+    runs-on: macos-13-xlarge
     environment: release
     needs: setup-environment
     strategy:
Repository: nodejs/node
Pull request: http2: fix FileHandle leak in respondWithFile

## Summary

This PR fixes a `FileHandle` leak in `lib/internal/http2/core.js` that causes `ERR_INVALID_STATE` when garbage collection occurs.

In `processRespondWithFD`, if `buildNgHeaderString` throws (e.g., due to invalid headers), the code would catch the error and destroy the stream but fail to close the file handle (`fd`) if it owned it (`self.ownsFd`). This leaves the file handle open, eventually triggering the GC error.

This patch adds a `tryClose(fd)` call in the catch block and error handling path to ensure the handle is properly released.

## References

- Fixes potential ERR_INVALID_STATE in http2 module.

Changed files:
filename: lib/internal/http2/core.js
patch: @@ -2680,6 +2680,8 @@ function processRespondWithFD(self, fd, headers, offset = 0, length = -1,
   try {
     headersList = buildNgHeaderString(headers, assertValidPseudoHeaderResponse);
   } catch (err) {
+    if (self.ownsFd)
+      tryClose(fd);
     self.destroy(err);
     return;
   }
@@ -2693,6 +2695,8 @@ function processRespondWithFD(self, fd, headers, offset = 0, length = -1,
   const ret = self[kHandle].respond(headersList, streamOptions);
 
   if (ret < 0) {
+    if (self.ownsFd)
+      tryClose(fd);
     self.destroy(new NghttpError(ret));
     return;
   }

filename: test/parallel/test-http2-respond-file-fd-leak.js
patch: @@ -0,0 +1,51 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const http2 = require('http2');
+const fs = require('fs');
+
+const fname = fixtures.path('elipses.txt');
+
+const server = http2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  const originalClose = fs.close;
+  let fdClosed = false;
+
+  fs.close = common.mustCall(function(fd, cb) {
+    fdClosed = true;
+    return originalClose.apply(this, arguments);
+  });
+
+  const headers = {
+    ':method': 'GET',
+    'content-type': 'text/plain'
+  };
+
+  stream.respondWithFile(fname, headers);
+
+  stream.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_HTTP2_INVALID_PSEUDOHEADER');
+  }));
+
+  stream.on('close', common.mustCall(() => {
+    fs.close = originalClose;
+    assert.strictEqual(fdClosed, true);
+  }));
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('close', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+
+  req.on('error', common.mustCall());
+  req.end();
+}));