Oct 5, 2026

vfs: add ComposableProvider for layered mountsJavaScript · 418 + / 0 −

Introduces 3 new declarations in lib/internal/vfs/providers/composable.js.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

lib/internal/vfs/providers/composable.js ↗ · 4 files

@@ -0,0 +1,416 @@+'use strict';++const {+  ArrayIsArray,+  ArrayPrototypePush,+  MapPrototypeHas,+  MapPrototypeSet,+  SafeMap,+  SafeSet,+  SetPrototypeAdd,+  SetPrototypeHas,+} = primordials;++const {+  codes: {+    ERR_INVALID_ARG_TYPE,+    ERR_OUT_OF_RANGE,+  },+} = require('internal/errors');+const { VirtualProvider } = require('internal/vfs/provider');+const { decodeOpenFlags } = require('internal/vfs/file_handle');+const {+  createENOENT,+  createENOTDIR,+  createENOTEMPTY,+  createEISDIR,+  createEROFS,+  createEEXIST,+  createEXDEV,+} = require('internal/vfs/errors');+const { posix: pathPosix } = require('path');+const { Dirent } = require('internal/fs/utils');+const { fs: { COPYFILE_EXCL } } = internalBinding('constants');

Fix quantized cachePython · 45 + / 1 −

Introduces 3 new declarations in src/transformers/cache_utils.py.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/cache_utils.py ↗ · 3 files

@@ -781,6 +791,37 @@ def _quantize(self, tensor, axis): ...     @abstractmethod     def _dequantize(self, q_tensor): ... +    def reorder_cache(self, beam_idx: torch.LongTensor) -> None:+        """Reorders this layer's cache for beam search."""+        if not self.is_initialized:+            return++        # Deferred to the next `update`, which dequantizes the states anyway. It is cloned as `beam_idx` belongs to+        # the caller, and composed with any pending one to cover several reorders in a row.+        beam_idx = beam_idx.to(self.device)+        self._pending_beam_idx = (+            beam_idx.clone() if self._pending_beam_idx is None else self._pending_beam_idx.index_select(0, beam_idx)+        )++        # Optional, as the residual cache is emptied whenever it is flushed into the quantized states+        if self.keys.numel() > 0:+            self.keys = self.keys.index_select(0, beam_idx.to(self.keys.device))+            self.values = self.values.index_select(0, beam_idx.to(self.values.device))++    def _apply_pending_reorder(self, keys: torch.Tensor, values: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:+        """Applies the reordering deferred by `reorder_cache` to freshly dequantized states."""+        if self._pending_beam_idx is None:+            return keys, values+        beam_idx = self._pending_beam_idx.to(keys.device)+        return keys.index_select(0, beam_idx), values.index_select(0, beam_idx)++    def reset(self) -> None:+        """Resets the cache values while preserving the objects."""+        super().reset()+        # The quantized states are dropped instead of zeroed, so that the next `update` quantizes from scratch+        self._quantized_keys = self._quantized_values = None+        self._pending_beam_idx = None

Annotate MIR with dataflow results for testing purposesRust · 167 + / 2 −

Introduces 14 new declarations in compiler/rustc_mir_dataflow/src/pretty.rs.

Adds new language design rather than adjusting what was there. Tests changed with it, with code of their own.

compiler/rustc_mir_dataflow/src/pretty.rs ↗ · 15 files

@@ -0,0 +1,132 @@+use std::io;++use rustc_attr_ir::{RustcMirKind, find_attr};+use rustc_data_structures::fx::FxIndexMap;+use rustc_middle::mir::{self, Body, Local, MirDumper, PassWhere, traversal};+use rustc_middle::ty::TyCtxt;++use crate::debuginfo::debuginfo_locals;+use crate::framework::Analysis;+use crate::impls::{MaybeLiveLocals, MaybeTransitiveLiveLocals, borrowed_locals};+use crate::{ResultsVisitor, visit_results};++type ExtraDataFn = dyn Fn(PassWhere, &mut dyn io::Write) -> io::Result<()>;++pub(crate) fn mir_pretty_extra_data<'tcx>(+    tcx: TyCtxt<'tcx>,+    body: &Body<'tcx>,+) -> Option<Box<ExtraDataFn>> {+    let def_id = body.source.def_id();+    let Some(kinds) = find_attr!(tcx, def_id, RustcMir(kind) => kind) else {+        return None;+    };+    let mut annotations = Annotations::default();+    for kind in kinds {+        match kind {+            RustcMirKind::PrettyLiveLocals => {+                let results = MaybeLiveLocals.iterate_to_fixpoint(tcx, body, None);+                let blocks = traversal::reachable(body).map(|(bb, _)| bb);+                visit_results(+                    body,+                    blocks,+                    &results,+                    &mut Annotator { annotations: &mut annotations },

[TTS] Per-dataset strip_text_annotations_for_metrics in MagpieTTS evaluationPython · 183 + / 22 −

Introduces 6 new declarations in nemo/collections/tts/modules/magpietts_inference/evaluate_generated_audio.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

nemo/collections/tts/modules/magpietts_inference/evaluate_generated_audio.py ↗ · 6 files

@@ -1024,3 +1071,58 @@ def compute_global_metrics(      pprint.pprint(avg_metrics)     return avg_metrics+++def _span_was_spoken(span: str, pred_text: str, no_space: bool = False) -> bool:+    """Return True if a normalized bracket span occurs in the normalized ASR hypothesis.++    For languages written with spaces, the span must appear as complete words in the hypothesis: ``breath`` matches+    ``take a breath`` but not ``breathing``. For zh and ja (``no_space=True``; their ``NoSpaceTextProcessor`` removes+    all spaces, so no word boundaries are left) the span only needs to appear somewhere inside the hypothesis. Other+    languages written without spaces are normalized by ``DefaultTextProcessor`` and follow the complete-words rule,+    which can miss spoken spans there.+    """+    if not span:+        return False+    if no_space:+        return span in pred_text+    return f" {span} " in f" {pred_text} "+++def _warn_if_stripped_spans_were_spoken(+    stripped_spans: list[list[str]],+    pred_texts: list[str],+    manifest_path: Optional[str] = None,+    no_space: bool = False,+) -> None:+    """Warn when square-bracket spans deleted from the reference show up verbatim in the ASR hypothesis.++    That is the signature of a dataset that uses ``[word]`` to mark emphasized *spoken* words rather than non-verbal+    tags: the words are spoken and transcribed, then counted as insertions against the truncated reference. This is a+    heuristic and only logs.+

Validate Get requests with RVGo · 173 + / 10 −

Introduces 4 new declarations in staging/src/k8s.io/apiserver/pkg/storage/testing/correctness/correctness.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

staging/src/k8s.io/apiserver/pkg/storage/testing/correctness/correctness.go ↗ · 7 files

@@ -942,6 +942,84 @@ func readTestCases() []testStep { 			CorrectResponse: Response{Err: invalidRVErr}, 			InvalidResponses: []Response{ 				{Object: withLabel(pod4, "17", "version", "v2")},+				{Object: nil, Err: apierrors.NewBadRequest(fmt.Sprintf("invalid resource version: %v", invalidRVErr))},+				{Object: nil, Err: nil},+			},+		},+		{+			Name: "Get pod4 with ResourceVersion=16 returns pod4 at RV>=16",+			Request: Request{+				Op:  OpGet,+				Key: pod4Key,+				Get: GetRequest{Options: storage.GetOptions{ResourceVersion: "16"}},+			},+			CorrectResponse: Response{+				Object: withLabel(pod4, "16", "version", "v1"),+			},+			InvalidResponses: []Response{+				{Object: withRV(pod4, "14")},+				{Object: withLabel(pod4, "19", "version", "v2")},+				{Object: &example.Pod{}},+				{Object: nil, Err: storage.NewKeyNotFoundError(pod4Key, 0)},+				{Object: nil, Err: storage.NewKeyNotFoundError(pod4Key, 18)},+				{Object: nil, Err: storage.NewTooLargeResourceVersionError(16, 18, 0)},+				{Object: nil, Err: nil},+			},+		},+		{+			Name: "Get pod4 with ResourceVersion=0 and ignoreNotFound=true returns pod4 or empty pod",+			Request: Request{+				Op:  OpGet,+				Key: pod4Key,+				Get: GetRequest{Options: storage.GetOptions{ResourceVersion: "0", IgnoreNotFound: true}},