Nov 5, 2026 – Nov 11, 2026

Improve distributed dataloader handlingPython · 112 + / 27 −

Introduces 4 new declarations in nemo/collections/common/data/lhotse/broadcasting.py.

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

nemo/collections/common/data/lhotse/broadcasting.py ↗ · 3 files

@@ -231,5 +254,67 @@ def _resolve_group_and_source(device_mesh, axes: Sequence[str]):      group = sub.get_group()     source_global_rank = int(sub.mesh.flatten()[0].item())-    _GROUP_CACHE[cache_key] = (group, source_global_rank)     return group, source_global_rank+++def _broadcast_packet(packet, group, src: int):+    """Broadcast one pre-serialized protocol packet over ``group``.++    Serializing before the first tensor collective lets the source replace an+    unpicklable data packet with a small error packet while receivers are still+    waiting for the packet size. Failures after a collective begins must be+    handled by the process-group timeout and distributed job teardown.+    """+    is_source = dist.get_rank() == src+    source_error = None+    if is_source:+        try:+            serialized = pickle.dumps(packet, protocol=pickle.HIGHEST_PROTOCOL)+        except Exception as error:+            source_error = error+            packet = _error_packet(error, "batch serialization failed")+            serialized = pickle.dumps(packet, protocol=pickle.HIGHEST_PROTOCOL)+    else:+        serialized = b""++    device = _broadcast_device(group)+    serialized_size = torch.tensor([len(serialized)], dtype=torch.long, device=device)+    dist.broadcast(serialized_size, src=src, group=group)++    if is_source:+        serialized_buffer = bytearray(serialized)

[masking] Fix packed sequences for abitrary mask formsPython · 49 + / 4 −

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

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

src/transformers/masking_utils.py ↗ · 2 files

@@ -186,6 +190,38 @@ def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:     return inner_mask  +def remap_positions_for_packed_sequence(mask_function: Callable, position_ids: torch.Tensor) -> Callable:+    """+    This function remaps the monotonically increasing `q_idx` and `kv_idx` to their actual per-sequence indices when we detect+    packed sequence format, i.e. several sequences inside the same batch dimension.+    Note that it is ensured that `position_ids.shape[1] == q_length == kv_length` here, so we can never have indexing problems here.+    If this was not the case, i.e. q_length < kv_length, we would need to infer the packed kv_position_ids, since the `position_ids`+    in the argument here are the packed query positions. Then we would need to remap q_idx and kv_idx with a different tensor.+    """++    def inner_mask(batch_idx: int, head_idx: int, q_idx: int, kv_idx: int) -> bool:+        return mask_function(batch_idx, head_idx, position_ids[batch_idx, q_idx], position_ids[batch_idx, kv_idx])++    return inner_mask+++def packed_sequence_compatibility_function(+    mask_function: Callable, position_ids: torch.Tensor, packed_sequence_mask: torch.Tensor+) -> Callable:+    """+    This function ensures compatibility of the current `mask_function` with packed sequence format, by making sure each sequence+    stays fully independent of all others, and the `q_idx` and `kv_idx` positions inside each sequence are correctly remapped to+    their actual values.+    Note that it is ensured that `position_ids.shape[1] == packed_sequence_mask.shape[1] == q_length == kv_length`, so we can never+    have indexing problems here.+    """+    # For packed sequences, we need to make sure each sequence are independent, as well as remapping the indices+    return and_masks(+        packed_sequence_mask_function(packed_sequence_mask),+        remap_positions_for_packed_sequence(mask_function, position_ids),+    )

Extract indexedWatchers.allMatchingWatchers iteratorGo · 33 + / 15 −

Introduces 4 new declarations in staging/src/k8s.io/apiserver/pkg/storage/cacher/cacher.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/cacher/cacher.go ↗ · 2 files

@@ -1257,24 +1258,41 @@ func (c *Cacher) startDispatching(event *watchCacheEvent) {  	namespace := event.ObjFields["metadata.namespace"] 	name := event.ObjFields["metadata.name"]-	forEachSelectionKey(namespace, name, triggerValues, supported,-		func(scope namespacedName) {-			for _, watcher := range c.watchers.scopeWatchers[scope] {-				c.watchersBuffer = append(c.watchersBuffer, watcher)-			}-		},-		func(indexValue string) {-			for _, watcher := range c.watchers.indexWatchers[indexValue] {-				c.watchersBuffer = append(c.watchersBuffer, watcher)+	for watcher := range c.watchers.allMatchingWatchers(namespace, name, triggerValues, supported) {+		c.watchersBuffer = append(c.watchersBuffer, watcher)+	}+}++func (i *indexedWatchers) allMatchingWatchers(namespace, name string, triggerValues []string, triggerSupported bool) iter.Seq[*cacheWatcher] {+	return func(yield func(*cacheWatcher) bool) {+		stopped := false+		yieldWatchers := func(watchers watchersMap) {+			if stopped {+				return 			}-		},-		func() {-			for _, watchers := range c.watchers.indexWatchers {-				for _, watcher := range watchers {-					c.watchersBuffer = append(c.watchersBuffer, watcher)+			for _, watcher := range watchers {+				if !yield(watcher) {+					stopped = true+					return

Change the span building of paths from first-to-last to chainedRust · 43 + / 4 −

Introduces 3 new declarations in compiler/rustc_parse/src/parser/path.rs.

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

compiler/rustc_parse/src/parser/path.rs ↗ · 4 files

@@ -208,23 +208,35 @@ impl<'a> Parser<'a> {         }          let lo = self.token.span;+        let mut path_span = None;         let mut segments = ThinVec::new();         let mod_sep_ctxt = self.token.span.ctxt();         if self.eat_path_sep() {+            chain_span(&mut path_span, self.prev_token.span);             segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));         }-        self.parse_path_segments(&mut segments, style, ty_generics)?;-        Ok(Path { segments, span: lo.to(self.prev_token.span) })+        self.parse_path_segments_with_path_span(&mut segments, style, ty_generics, &mut path_span)?;+        Ok(Path { segments, span: path_span.unwrap() })     }      pub(super) fn parse_path_segments(         &mut self,         segments: &mut ThinVec<PathSegment>,         style: PathStyle,         ty_generics: Option<&Generics>,+    ) -> PResult<'a, ()> {+        self.parse_path_segments_with_path_span(segments, style, ty_generics, &mut None)+    }++    fn parse_path_segments_with_path_span(+        &mut self,+        segments: &mut ThinVec<PathSegment>,+        style: PathStyle,+        ty_generics: Option<&Generics>,+        path_span: &mut Option<Span>,     ) -> PResult<'a, ()> {         loop {

chat: allow TTS model to provide custom text normalizer via jinjaC++ · 929 + / 0 −

Introduces 15 new declarations in common/chat-tts-norm.cpp.

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

common/chat-tts-norm.cpp ↗ · 7 files

@@ -0,0 +1,864 @@+#include "chat-tts-norm.h"++#include "jinja/runtime.h"+#include "jinja/value.h"++#include <algorithm>+#include <climits>+#include <stdexcept>+#include <string>+#include <vector>++// TTS normalization patterns, see docs/tts-norm-patterns.md for the specification+// keep this file in sync with the python reference: scripts/chat_tts_norm.py++using namespace jinja;++//+// character classes+// they are defined with explicit codepoint ranges, independent of any unicode database version,+// so that the C++ and python implementations agree on every codepoint+//++struct tts_norm_range {+    uint32_t lo;+    uint32_t hi;+};++static const tts_norm_range TTS_NORM_SPACE[] = {+    {0x0009, 0x000D}, {0x0020, 0x0020}, {0x0085, 0x0085}, {0x00A0, 0x00A0}, {0x1680, 0x1680},+    {0x2000, 0x200A}, {0x2028, 0x2029}, {0x202F, 0x202F}, {0x205F, 0x205F}, {0x3000, 0x3000},+};++static const tts_norm_range TTS_NORM_PUNCT[] = {

Add support for the xing4_0 C++ · 884 + / 1 −

Introduces 3 new declarations in src/models/xing4-0.cpp.

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

src/models/xing4-0.cpp ↗ · 13 files

@@ -0,0 +1,828 @@+#include "models.h"++#include <cmath>+#include <stdexcept>+#include <string>++static size_t xing4_0_elem_offset(const ggml_tensor * t, int64_t i) {+    return ggml_row_size(t->type, i);+}++static ggml_tensor * xing4_0_view_1d(ggml_context * ctx, ggml_tensor * t, int64_t ne0, int64_t i0) {+    return ggml_view_1d(ctx, t, ne0, xing4_0_elem_offset(t, i0));+}++static ggml_tensor * xing4_0_view_2d(+        ggml_context * ctx,+        ggml_tensor  * t,+        int64_t        ne0,+        int64_t        ne1,+        int64_t        i0) {+    return ggml_view_2d(ctx, t, ne0, ne1, t->nb[1], xing4_0_elem_offset(t, i0));+}++// mean over the hyper-connection streams: [n_embd, hc, n_tokens] -> [n_embd, n_tokens]+static ggml_tensor * xing4_0_hc_mean(ggml_context * ctx, ggml_tensor * x) {+    const int64_t hc = x->ne[1];++    ggml_tensor * acc = ggml_view_2d(ctx, x, x->ne[0], x->ne[2], x->nb[2], 0);+    for (int64_t s = 1; s < hc; ++s) {+        acc = ggml_add(ctx, acc, ggml_view_2d(ctx, x, x->ne[0], x->ne[2], x->nb[2], s*x->nb[1]));+    }+    return ggml_scale(ctx, acc, 1.0f/hc);+}

InterPodAffinity: handle namespaceSelector in assigned-pod queueing hintsGo · 120 + / 23 −

Introduces 4 new declarations in pkg/scheduler/framework/plugins/interpodaffinity/plugin.go.

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

pkg/scheduler/framework/plugins/interpodaffinity/plugin.go ↗ · 3 files

@@ -162,6 +163,47 @@ func GetNamespaceLabelsSnapshot(logger klog.Logger, ns string, nsLister listersv 	return } +// termsNeedNamespaceLabels reports whether matching any of the terms against+// any of the pods requires the pods' namespace labels. A term that already+// matches the pod namespace via Namespaces, or whose namespace selector is+// empty/nothing, can be evaluated without looking the namespace up.+func termsNeedNamespaceLabels(terms []fwk.AffinityTerm, pods ...*v1.Pod) bool {+	for i := range terms {+		term := &terms[i]+		if term.NamespaceSelector == nil ||+			labels.MatchesNothing(term.NamespaceSelector) ||+			term.NamespaceSelector.Empty() {+			continue+		}+		for _, pod := range pods {+			if pod == nil || term.Namespaces.Has(pod.Namespace) {+				continue+			}+			if term.Selector.Matches(labels.Set(pod.Labels)) {+				return true+			}+		}+	}+	return false+}++// namespaceLabelsForNamespace returns namespace labels, whether the namespace+// was found, and an error. A missing namespace is reported as found=false with+// no error; other lister errors are returned to the caller.+func (pl *InterPodAffinity) namespaceLabelsForNamespace(namespace string, needed bool) (labels.Set, bool, error) {+	if !needed {+		return nil, true, nil

Improve Request Insights context menus and trace interactionsTypeScript · 356 + / 80 −

Introduces 8 new declarations in packages/next/src/next-devtools/dev-overlay/components/request-insights/request-insights-panel.tsx.

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

packages/next/src/next-devtools/dev-overlay/components/request-insights/request-insights-panel.tsx ↗ · 5 files

@@ -696,53 +743,165 @@ function RequestRow({     requestType.type === 'rsc'   )   const clockTime = formatClockTime(request.startTime)-  const bypassesProxy = request.proxyStatus === 'bypassed'    return (-    <button-      aria-label={`${isInstantInsights ? `Instant Insights for ${requestUrl}` : requestUrl}, ${requestType.accessibleLabel}, ${bypassesProxy ? 'Did not match the configured proxy, ' : ''}${formatDuration(request.durationMs)}, ${clockTime}`}-      className="request-insights-row"-      data-internal={isInstantInsights || undefined}-      data-nested={nested || undefined}-      data-page-load={pageLoad}-      data-selected={selected}-      onClick={onSelect}-      type="button"+    <ContextMenu.Root+      onOpenChange={onContextMenuOpenChange}+      open={contextMenuOpen}     >-      <span className="request-insights-status" data-status={request.status} />-      <span className="request-insights-route">-        {nested ? <NestedArrowIcon /> : null}-        <span className="request-insights-route-label">-          {isInstantInsights ? 'Instant Insights' : requestUrl}-        </span>-      </span>-      <span className="request-insights-duration">-        {formatDuration(request.durationMs)}-      </span>-      <span className="request-insights-meta request-insights-row-metadata">+      <ContextMenu.Trigger+        render={+          <button

Windows unbuffered model loadC++ · 265 + / 35 −

Introduces 3 new declarations in src/llama-mmap.cpp.

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

src/llama-mmap.cpp ↗ · 3 files

@@ -123,24 +207,159 @@ struct llama_file::impl {         li.QuadPart = offset;         BOOL ret = SetFilePointerEx(fp_win32, li, NULL, whence);         if (!ret) {-            throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));+            throw std::runtime_error(format("seek error: %s", GetErrorMessageWin32(GetLastError()).c_str()));         }     } -    void read_raw(void * ptr, size_t len) {+    void read_raw_unsafe(void * ptr, size_t len) {+        if (len == 0) {+            return;+        }++        const size_t read_offset = tell();+        if (read_offset > size) {+            throw std::runtime_error("unexpectedly reached end of file");+        }++        if (!has_direct_io()) {+            const size_t read_size = std::min(len, size - read_offset);+            size_t bytes_read = 0;+            while (bytes_read < read_size) {+                const DWORD to_read = (DWORD) std::min<size_t>(read_size - bytes_read, MAXDWORD);+                DWORD chunk_read = 0;+                BOOL result = ReadFile(fp_win32, reinterpret_cast<char *>(ptr) + bytes_read,+                                       to_read, &chunk_read, NULL);+                if (!result) {+                    throw std::runtime_error(format("read error: %s", GetErrorMessageWin32(GetLastError()).c_str()));+                }+                if (chunk_read < to_read) {+                    throw std::runtime_error("unexpectedly reached end of file");+                }

Harden our Jinja sandboxingPython · 87 + / 6 −

Introduces 8 new declarations in src/transformers/utils/chat_template_utils.py.

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

src/transformers/utils/chat_template_utils.py ↗ · 4 files

@@ -620,6 +656,42 @@ def _alias_reasoning_fields(chat: ChatType) -> ChatType:     return aliased_chat  +def _plain_template_data(value: Any) -> Any:+    # Chat templates come from the Hub, but callers often put rich objects in their inputs, like the decoded images,+    # arrays and tensors in multimodal content blocks. Those objects have methods that the sandbox doesn't know are+    # dangerous (some of them write files!), so we rebuild everything the template sees out of plain JSON types,+    # and replace anything else with an inert placeholder. Templates only check whether media keys are present,+    # and never read their values, so this doesn't change what they render.+    if value is None or type(value) in (str, int, float, bool):+        # Exact JSON scalars are safe as-is+        return value+    elif isinstance(value, str):+        # Subclasses (enums, numpy scalars, ...) can carry extra methods, so we strip them back to the base type+        return str.__str__(value)+    elif isinstance(value, int):+        return int.__int__(value)+    elif isinstance(value, float):+        return float.__float__(value)+    elif isinstance(value, Mapping):+        return {_plain_template_data(key): _plain_template_data(item) for key, item in value.items()}+    elif isinstance(value, list):+        return [_plain_template_data(item) for item in value]+    elif isinstance(value, tuple):+        return tuple(_plain_template_data(item) for item in value)+    elif isinstance(value, np.generic):+        # `np.bool_(False)` would otherwise become a truthy placeholder string+        return _plain_template_data(value.item())+    elif dataclasses.is_dataclass(value) and not isinstance(value, type):+        # Fields are read one level at a time, so arrays and images inside are not deep-copied+        return {field.name: _plain_template_data(getattr(value, field.name)) for field in dataclasses.fields(value)}+    elif callable(getattr(value, "model_dump", None)):+        # Pydantic models

OpenVINO exporter: let OpenVINO fuse attention, RoPE, the KV cache and compressed matmulsPython · 332 + / 80 −

Introduces 19 new declarations in src/transformers/exporters/exporter_openvino.py.

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

src/transformers/exporters/exporter_openvino.py ↗ · 6 files

@@ -1162,6 +1299,123 @@ def _fix_index_put_bool_mask(gm, node): # To add a new patch: define a `_patch_*` factory and decorate it.  +@register_patch("openvino", "torch.Tensor.__neg__", "torch.neg", "torch.Tensor.neg")+def _patch_neg(original):+    """Negate as a multiply by ``-1``, the form OV's CPU plugin fuses ``rotate_half`` (so RoPE) from.++    The frontend lowers ``aten.neg`` to a multiply by a ``Convert``ed ``-1`` that it marks+    ``DisableConstantFolding``, which keeps the plugin's RoPE fusion from matching until the IR is+    serialized and read back: the model this exporter returns would run RoPE decomposed.+    """++    def patch(input):+        return input * -1++    return patch+++@register_patch("openvino", "torch.nn.Linear.forward")+def _patch_linear_forward(original):+    """Cast the 16-bit weight [`patch_16bit_model`] set aside to the f32 activations, inside the graph."""++    def patch(self, input):+        if "_16bit_weight" not in self._parameters:+            return original(self, input)+        weight = self._16bit_weight.to(input.dtype)+        bias = _16bit_parameter(self, "bias")+        if bias is not None:+            bias = bias.to(input.dtype)+        return torch.nn.functional.linear(input, weight, bias)++    return patch+

Extract eventsAfterLocked and checkResourceVersionLocked methodsGo · 40 + / 13 −

Introduces 3 new declarations in staging/src/k8s.io/apiserver/pkg/storage/cacher/watch_cache_history.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/cacher/watch_cache_history.go ↗ · 2 files

@@ -219,26 +220,52 @@ func (w *watchCacheHistory) suggestedWatchChannelSize(indexExists, triggerUsed b // retrieve events since a certain resourceVersion. This function assumes to // be called under the lock. func (w *watchCacheHistory) GetIntervalLocked(resourceVersion uint64, locker sync.Locker) (*watchCacheInterval, error) {-	size := w.endIndex - w.startIndex+	if err := w.checkResourceVersionLocked(resourceVersion); err != nil {+		return nil, err+	}+	first := w.firstIndexAfterLocked(resourceVersion)+	indexerFunc := func(i int) *watchCacheEvent {+		return w.cache[i%w.capacity]+	}+	ci := newCacheInterval(first, w.endIndex, indexerFunc, w.config.indexValidator, resourceVersion, locker)+	return ci, nil+}++// eventsAfterLocked yields buffered events with ResourceVersion > resourceVersion+// in ascending ResourceVersion order. This function assumes to be called under+// the lock.+func (w *watchCacheHistory) eventsAfterLocked(resourceVersion uint64) iter.Seq[*watchCacheEvent] {+	return func(yield func(*watchCacheEvent) bool) {+		for i := w.firstIndexAfterLocked(resourceVersion); i < w.endIndex; i++ {+			if !yield(w.cache[i%w.capacity]) {+				return+			}+		}+	}+}++// checkResourceVersionLocked verifies that history is initialized and can+// still serve events strictly after resourceVersion. This function assumes to+// be called under the lock.+func (w *watchCacheHistory) checkResourceVersionLocked(resourceVersion uint64) error { 	oldest, ok := w.oldestServableLocked()