Oct 1, 2026 – Oct 7, 2026

component-base/metrics/testutil: compute quantiles from native histogramsGo · 163 + / 0 −

Introduces 4 new declarations in staging/src/k8s.io/component-base/metrics/testutil/metrics.go.

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

staging/src/k8s.io/component-base/metrics/testutil/metrics.go ↗ · 2 files

@@ -383,6 +413,139 @@ func (hist *Histogram) Quantile(q float64) float64 { 	return bucketQuantile(q, buckets) } +// nativeBuckets decodes the sparse, exponentially sized buckets of a native+// histogram (https://www.kubernetes.dev/resources/keps/5808/)+// into a list of non-cumulative buckets covering the real number line,+// sorted by ascending upper bound. It returns nil if hist doesn't carry any+// native histogram data (e.g. because native histograms are disabled or the+// histogram has no observations).+func (hist *Histogram) nativeBuckets() []bucket {+	h := hist.Histogram+	if len(h.GetPositiveSpan()) == 0 && len(h.GetNegativeSpan()) == 0 &&+		h.GetZeroCount() == 0 && h.GetZeroCountFloat() == 0 {+		return nil+	}++	schema := h.GetSchema()+	var buckets []bucket++	for idx, count := range decodeNativeHistogramSpans(h.GetPositiveSpan(), h.GetPositiveDelta(), h.GetPositiveCount()) {+		if count <= 0 {+			continue+		}+		lower, upper := nativeHistogramBucketBounds(schema, idx)+		buckets = append(buckets, bucket{lowerBound: lower, upperBound: upper, count: count})+	}+	for idx, count := range decodeNativeHistogramSpans(h.GetNegativeSpan(), h.GetNegativeDelta(), h.GetNegativeCount()) {+		if count <= 0 {+			continue+		}+		lower, upper := nativeHistogramBucketBounds(schema, idx)+		buckets = append(buckets, bucket{lowerBound: -upper, upperBound: -lower, count: count})+	}

kubectl: separate `attach` flags from runtime optionsGo · 75 + / 48 −

Introduces 5 new declarations in staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go.

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

staging/src/k8s.io/kubectl/pkg/cmd/attach/attach.go ↗ · 2 files

@@ -94,20 +113,62 @@ type AttachOptions struct { 	Config        *restclient.Config } -// NewAttachOptions creates the options for attach-func NewAttachOptions(streams genericiooptions.IOStreams) *AttachOptions {-	return &AttachOptions{-		StreamOptions: exec.StreamOptions{-			IOStreams: streams,-		},-		Attach:     &DefaultRemoteAttach{},-		AttachFunc: DefaultAttachFunc,+// ToOptions converts from CLI inputs to runtime inputs.+func (flags *AttachFlags) ToOptions(f cmdutil.Factory, cmd *cobra.Command, args []string) (*AttachOptions, error) {+	namespace, _, err := f.ToRawKubeConfigLoader().Namespace()+	if err != nil {+		return nil, err+	}++	getPodTimeout, err := cmdutil.GetPodRunningTimeoutFlag(cmd)+	if err != nil {+		return nil, err 	}++	config, err := f.ToRESTConfig()+	if err != nil {+		return nil, err+	}++	o := &AttachOptions{+		Namespace:     namespace,+		ContainerName: flags.ContainerName,+		Stdin:         flags.Stdin,+		TTY:           flags.TTY,

test_runner: add mock call assertions to t.assertJavaScript · 106 + / 0 −

Introduces 6 new declarations in lib/internal/test_runner/assert.js.

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

lib/internal/test_runner/assert.js ↗ · 4 files

@@ -28,13 +36,110 @@ const methodsToCopy = [ ]; let assertMap; +function getMockContext(fn) {+  const { MockFunctionContext } = require('internal/test_runner/mock/mock');+  const ctx = fn?.mock;++  if (!(ctx instanceof MockFunctionContext)) {+    throw new ERR_INVALID_ARG_TYPE('fn', 'mock function', fn);+  }++  return ctx;+}++function called(fn, message) {+  const count = getMockContext(fn).callCount();++  if (count === 0) {+    throw new AssertionError({+      __proto__: null,+      message: message ?? 'Expected mock function to have been called',+      actual: count,+      operator: 'called',+      stackStartFn: called,+    });+  }+}++function callCount(fn, times, message) {+  validateInteger(times, 'times', 0);+  const count = getMockContext(fn).callCount();++  if (count !== times) {

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: Improve Dial rendering and themingPython · 111 + / 20 −

Introduces 9 new declarations in panel/widgets/indicators.py.

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

panel/widgets/indicators.py ↗ · 3 files

@@ -705,17 +705,98 @@ def __init__(self, **params):     def _update_value_bounds(self):         self.param.value.bounds = self.bounds +    @property+    def _unfilled_color(self) -> str:+        # Without an outline, whitesmoke is indistinguishable from a white page.+        if self.unfilled_color:+            return self.unfilled_color+        return '#424242' if config.theme == 'dark' else '#e8e8e8'++    def _angles(self) -> tuple[float, float, float]:+        start = (np.radians(360-self.start_angle) - pi % (2*pi)) + pi+        end = (np.radians(360-self.end_angle) - pi % (2*pi)) + pi+        distance = (abs(end-start) % (pi*2))+        if end>start:+            distance = (pi*2)-distance+        return start, end, distance++    def _size(self) -> tuple[int, int]:+        height = self.height or self.width or 250+        return self.width or height, height++    def _font_sizes(self) -> tuple[str, str, str]:+        scale = (self._size()[1]/400)+        title_size = self.title_size if self.title_size else '%spt' % (scale*32)+        value_size = self.value_size if self.value_size else '%spt' % (scale*48)+        tick_size = self.tick_size if self.tick_size else '%spt' % (scale*18)+        return title_size, value_size, tick_size++    @staticmethod+    def _font_px(size: str) -> float:+        # Only reserves layout space, so a rough guess for unknown units is fine.+        try:

net: race family autoselection attemptsJavaScript · 189 + / 80 −

Introduces 10 new declarations in lib/net.js.

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

lib/net.js ↗ · 10 files

@@ -1477,107 +1488,205 @@ function internalConnect( }  -function internalConnectMultiple(context, canceled) {+function closeConnectionAttempts(context) {   clearTimeout(context[kTimeout]);+  context[kTimeout] = null;+  context.done = true;+  for (let i = 0; i < context.pending.length; i++) {+    const { handle, req, own } = context.pending[i];+    req.oncomplete = undefined;+    // The socket's own handle is closed by whoever replaces or destroys it.+    if (!own) handle.close();+  }+  context.pending.length = 0;+}++function removePendingAttempt(context, req) {+  const { pending } = context;+  for (let i = 0; i < pending.length; i++) {+    if (pending[i].req === req) {+      const attempt = pending[i];+      ArrayPrototypeSplice(pending, i, 1);+      return attempt;+    }+  }+}++function connectMultipleError(context) {+  // Errors are stored by attempt index to preserve the attempt order.+  const errors = [];+  for (let i = 0; i < context.errors.length; i++) {+    if (context.errors[i] !== undefined) ArrayPrototypePush(errors, context.errors[i]);

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

ENH: respect display.precision for complex and float Interval values (GH#25920)Python · 123 + / 28 −

Introduces 5 new declarations in pandas/io/formats/format.py.

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

pandas/io/formats/format.py ↗ · 7 files

@@ -1569,6 +1577,84 @@ def _format_strings(self) -> list[str]:         return fmt_values  +def _format_complex(value: complex, float_format: FloatFormatType | None) -> str:+    """+    Format a complex scalar from an object-dtype array.++    ``float_format`` is applied to each part separately so that formats+    written for floats also work here.+    """+    if float_format is None:+        return printing.format_with_precision(value)+    if isinstance(float_format, str):+        # "%"-style strings reach here unconverted+        fmt_str = float_format+        float_format = lambda part: fmt_str % part+    real = str(float_format(value.real)).strip()+    imag = str(float_format(value.imag)).strip()+    if not imag.startswith("-"):+        imag = f"+{imag}"+    return f"({real}{imag}j)"+++def _maybe_format_float_intervals(+    values: ArrayLike,+    formatter: Callable | None,+    float_format: FloatFormatType | None,+    decimal: str,+) -> ArrayLike:+    """+    Pre-format float-endpoint Interval column values (GH#25920).++    Only column values go through here; index labels and Categorical

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 },

cacher: stream watch cache snapshots without an item sliceGo · 47 + / 43 −

Introduces 7 new declarations in staging/src/k8s.io/apiserver/pkg/storage/cacher/watch_cache_interval.go.

Adds new framework internals 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_interval.go ↗ · 4 files

@@ -250,55 +266,46 @@ type snapshotCacheIntervalSource struct { 	buffer *watchCacheIntervalBuffer } -func (s *snapshotCacheIntervalSource) Next() (*watchCacheEvent, error) {+func (s *snapshotCacheIntervalSource) next() (*watchCacheEvent, error) { 	event, exists := s.buffer.next() 	if !exists { 		return nil, nil 	} 	return event, nil } +func (s *snapshotCacheIntervalSource) All() iter.Seq2[*watchCacheEvent, error] {+	return eventsFromNext(s.next)+}+ // lazySnapshotCacheIntervalSource serves events from an immutable snapshot.-// The snapshot reference is captured under the watchCache lock, but the O(N)-// traversal that materializes the events is deferred until the first Next()-// call so that it runs off the watchCache lock.+// The snapshot reference is captured under the watchCache lock, while its+// contents are traversed one event at a time after releasing that lock. type lazySnapshotCacheIntervalSource struct { 	// snapshot is an immutable point-in-time copy of the store. 	snapshot store.Snapshot 	// resourceVersion is assigned to every watchCacheEvent produced by this source. 	resourceVersion uint64-	// loaded indicates whether items has been materialized from the snapshot.-	loaded bool-	// items holds the result of OrderedListPrefix, populated on the first Next() call-	items []interface{}-	// currentIndex tracks the current position within items.-	currentIndex int

llama : add a GPU cache for MoE experts kept in host memoryC++ · 739 + / 13 −

Introduces 14 new declarations in src/llama-moe-cache.cpp.

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

src/llama-moe-cache.cpp ↗ · 14 files

@@ -0,0 +1,550 @@+#include "llama-moe-cache.h"++#include "llama-impl.h"+#include "llama-model.h"++#include "ggml-cpp.h"++#include <algorithm>+#include <stdexcept>+#include <unordered_map>+#include <vector>++namespace {++// LRU of the experts of a group of layers, the slot of each expert is kept in the slot map of its layer+struct moe_cache_lru {+    int32_t n_expert = 0;+    int32_t n_slots  = 0;++    std::vector<int32_t *> slot_map; // [n_layer] data of the slot maps, -1 if the expert is not cached+    std::vector<int32_t>   key_of;   // [n_slots] il*n_expert + expert, -1 if empty++    // doubly linked list of the slots, head is the least recently used+    std::vector<int32_t> prev;+    std::vector<int32_t> next;+    int32_t head = -1;+    int32_t tail = -1;++    std::vector<uint32_t> seen; // [n_expert]+    uint32_t seen_gen = 0;+    std::vector<int32_t> uniq;++    void init(int32_t n_layer, int32_t n_expert, int32_t n_slots) {

[ai-upgrade] discover upgrade models and reasoning efforts from agent CLIsTypeScript · 477 + / 220 −

Introduces 11 new declarations in packages/next/src/lib/upgrade/harness.ts.

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

packages/next/src/lib/upgrade/harness.ts ↗ · 3 files

@@ -386,177 +325,200 @@ export async function handoffUpgrade(     return 'handed_off'   } -  let stage: 'harness' | 'model' | 'effort' | 'permission' | 'worktree' =-    'harness'-  let harness: UpgradeHarness | undefined-  let model: { id: string; efforts: readonly string[] } | undefined-  let effort: string | undefined-  let autoPermissionArgs: string[] | null = null-  let approvalPermissionArgs: string[] = []-  let permissionArgs: string[] = []-  let useAuto = true-  let useWorktree = true-  let codexModels: ReturnType<typeof getCodexModels> | undefined-  let codexAutoReview: boolean | undefined-  let claudePermissionSupport:-    | ReturnType<typeof getClaudePermissionSupport>-    | undefined--  while (true) {-    if (stage === 'harness') {-      const choice = await chooseHarness(installed, harness?.name)-      if (choice === 'copy') {-        const method = copyUpgradePrompt(resolvePrompt(prompt, null), false)-        onHandoff?.(method, null)-        return 'handed_off'-      }-      if (!choice) {-        break-      }-      harness = choice-      stage = 'model'-    } else if (stage === 'model') {