Nov 5, 2026

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

Turbopack: keep IIFEs with a PURE-annotated callee in production buildsRust · 138 + / 24 −

Introduces 20 new declarations in turbopack/crates/turbopack-ecmascript/src/swc_comments.rs.

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

turbopack/crates/turbopack-ecmascript/src/swc_comments.rs ↗ · 9 files

@@ -266,6 +245,127 @@ impl Comments for ImmutableComments {     } } +/// Checks whether `comments` contain a `@__FLAG__` / `#__FLAG__` block comment, using the same+/// matching rules as SWC's default [Comments::has_flag], but without mutating anything.+fn comments_have_flag(comments: &[Comment], flag: &str) -> bool {+    for c in comments {+        if c.kind == CommentKind::Block {+            for line in c.text.lines() {+                // jsdoc+                let line = line.trim_start_matches(['*', ' ']);+                let line = line.trim();++                //+                if line.len() == (flag.len() + 5)+                    && (line.starts_with("#__") || line.starts_with("@__"))+                    && line.ends_with("__")+                    && flag == &line[3..line.len() - 2]+                {+                    return true;+                }+            }+        }+    }++    false+}++/// A read-only [Comments] view over several comment stores.+///+/// Some SWC transforms (e.g. the fixer) need to *read* comments to make correct decisions: the+/// fixer keeps the parentheses around a `/* @__PURE__ */`-annotated callee, which would otherwise+/// move the annotation onto the outer call. The comment stores at that point must not be changed

Add `Discriminant::ord`Rust · 129 + / 1 −

Introduces 17 new declarations in library/core/src/mem/mod.rs.

Adds new language design rather than adjusting what was there. Read the linked PR for the surrounding test context.

library/core/src/mem/mod.rs ↗ · 2 files

@@ -1325,6 +1401,58 @@ impl<T> fmt::Debug for Discriminant<T> {     } } +#[unstable(feature = "discriminant_ord", issue = "165438")]+impl<T> Copy for DiscriminantOrd<T> {}++#[unstable(feature = "discriminant_ord", issue = "165438")]+impl<T> clone::Clone for DiscriminantOrd<T> {+    fn clone(&self) -> Self {+        *self+    }+}++#[doc(hidden)]+#[unstable(feature = "trivial_clone", issue = "none")]+unsafe impl<T> TrivialClone for DiscriminantOrd<T> {}++#[unstable(feature = "discriminant_ord", issue = "165438")]+impl<T> cmp::PartialEq for DiscriminantOrd<T> {+    fn eq(&self, rhs: &Self) -> bool {+        self.0 == rhs.0+    }+}++#[unstable(feature = "discriminant_ord", issue = "165438")]+impl<T> cmp::Eq for DiscriminantOrd<T> {}++#[unstable(feature = "discriminant_ord", issue = "165438")]+impl<T> hash::Hash for DiscriminantOrd<T> {+    fn hash<H: hash::Hasher>(&self, state: &mut H) {+        self.0.hash(state);+    }+}

[compressed-tensors] better path through conversion mappingPython · 48 + / 53 −

Introduces 1 new declaration in src/transformers/quantizers/quantizer_compressed_tensors.py.

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

src/transformers/quantizers/quantizer_compressed_tensors.py ↗ · 6 files

@@ -90,47 +89,35 @@ def validate_environment(self, *args, **kwargs):             self.use_fp8_kernel = False      def _process_model_before_weight_loading(self, model, **kwargs):-        ct_config = self.compressor.quantization_config-        remaining_groups = dict(ct_config.config_groups)+        if self.quantization_config.dequantize:+            # The model stays dense: the `dequantize` load operation runs on every checkpoint weight+            return+        from compressed_tensors.quantization import apply_quantization_config +        ct_config = deepcopy(self.compressor.quantization_config)         if self.use_fp8_kernel:             from ..integrations.compressed_tensors import replace_with_compressed_tensors_fp8_linear              # Quantization may only target a subset of the layers: each config group scopes             # its scheme with `targets` (class names or `re:` regexes) minus `ignore`.-            fp8_groups = {name: group for name, group in remaining_groups.items() if _is_fp8_scheme(group)}-            remaining_groups = {name: group for name, group in remaining_groups.items() if name not in fp8_groups}-+            fp8_groups = {name: group for name, group in ct_config.config_groups.items() if _is_fp8_scheme(group)}+            ct_config.config_groups = {+                name: group for name, group in ct_config.config_groups.items() if name not in fp8_groups+            }             self.modules_to_not_convert = self.get_modules_to_not_convert(model, None, model._keep_in_fp32_modules)-            targets = [target for group in fp8_groups.values() for target in group.targets]             replace_with_compressed_tensors_fp8_linear(                 model,-                targets=targets,+                targets=[target for group in fp8_groups.values() for target in group.targets],                 ignore=ct_config.ignore,                 modules_to_not_convert=self.modules_to_not_convert,             )