Sep 30, 2026 – Oct 6, 2026

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(next/image): Pin DNS resolution when fetching external images TypeScript · 362 + / 55 −

Introduces 13 new declarations in packages/next/src/server/image-optimizer.ts.

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

packages/next/src/server/image-optimizer.ts ↗ · 5 files

@@ -518,24 +537,286 @@ function isRedirect(statusCode: number) {   return [301, 302, 303, 307, 308].includes(statusCode) } +function upstreamTimedOut(href: string): ImageError {+  Log.error('upstream image response timed out for', href)+  return new ImageError(+    504,+    '"url" parameter is valid but upstream response timed out'+  )+}++const agentOptions = {+  keepAlive: true,+  timeout: 7_000,+}+type ImageRequestOptions = HttpRequestOptions & { imageLookupKey?: string }+type AgentGetName = (options?: HttpRequestOptions) => string++const getHttpAgentName = (+  HttpAgent.prototype as HttpAgent & { getName: AgentGetName }+).getName+const getHttpsAgentName = (+  HttpsAgent.prototype as HttpsAgent & { getName: AgentGetName }+).getName++class ImageHttpAgent extends HttpAgent {+  getName(options: ImageRequestOptions = {}): string {+    return `${getHttpAgentName.call(this, options)}:${options.imageLookupKey ?? ''}`+  }+}++class ImageHttpsAgent extends HttpsAgent {+  getName(options: ImageRequestOptions = {}): string {

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

model: Add GTE to TransformersPython · 1050 + / 0 −

Introduces 67 new declarations in src/transformers/models/gte/modeling_gte.py.

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

src/transformers/models/gte/modeling_gte.py ↗ · 13 files

@@ -0,0 +1,660 @@+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨+#           This file was automatically generated from src/transformers/models/gte/modular_gte.py.+#               Do NOT edit this file manually as any edits will be overwritten by the generation of+#             the file from the modular. If any change should be done, please apply the change to the+#                          modular_gte.py file directly. One of our CI enforces this.+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨+# Copyright 2026 the HuggingFace Team. All rights reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+#     http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.++from collections.abc import Callable++import torch+import torch.nn as nn+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss++from ...activations import ACT2FN, gelu+from ...integrations import use_kernel_forward_from_hub, use_kernelized_func+from ...masking_utils import create_bidirectional_mask+from ...modeling_layers import GradientCheckpointingLayer+from ...modeling_outputs import (+    BaseModelOutputWithPooling,+    MaskedLMOutput,

[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') {