Nov 11, 2026

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[] = {

Watchcache stalled resyncGo · 192 + / 54 −

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

@@ -571,24 +575,126 @@ func (c *Cacher) resyncWatchers() { 		return 	} +	var stalledWatchers indexedWatchers+	var minResourceVersion uint64+ 	for _, watcher := range c.unsyncedWatchers {-		c.unsyncedWatchers.deleteWatcher(watcher) 		if watcher.stopped {+			c.unsyncedWatchers.deleteWatcher(watcher) 			continue 		}-		// TODO: Once stalled watchers are moved back to unsyncedWatchers,-		// compute and send only catchup events after the last dispatched-		// resourceVersion instead of re-initializing the watcher interval.-		cacheInterval, err := c.initWatcherIntervalLocked(watcher)-		if err != nil {+		if !watcher.synced.IsNotified() {+			c.unsyncedWatchers.deleteWatcher(watcher)+			cacheInterval, err := c.initWatcherIntervalLocked(watcher)+			if err != nil {+				watcher.input <- watcherInput{err: err}+				// Drain input so watcher.done stays open until process() delivers+				// the queued watch.Error event; non-draining stop closes watcher.done+				// immediately, causing sendWatchError to drop the error.+				c.stopWatcherLocked(watcher, true)+				continue+			}+			c.registerWatcherLocked(watcher, cacheInterval)+			continue+		}++		if len(watcher.input) == cap(watcher.input) {

Support Enum in get_json_schema, raise on custom classesPython · 52 + / 20 −

Introduces 2 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 ↗ · 3 files

@@ -100,20 +106,47 @@ def _get_json_schema_type(param_type: type) -> dict[str, str]:         import torch          type_mapping[torch.Tensor] = {"type": "audio"}-    return type_mapping.get(param_type, {"type": "object"})+    return type_mapping.get(param_type)+++def _enum_values_to_json_schema(values: list) -> dict:+    # The "type" lists each JSON type that appears in the values once, in the order they first appear+    value_types = list(dict.fromkeys(JSON_SCALAR_TYPES[type(value)] for value in values))+    return {"type": value_types[0] if len(value_types) == 1 else value_types, "enum": values}   def _parse_type_hint(hint: str) -> dict:     origin = get_origin(hint)     args = get_args(hint) -    if origin is None:-        try:-            return _get_json_schema_type(hint)-        except KeyError:+    if origin is None and isinstance(hint, type) and issubclass(hint, Enum):+        # An Enum class becomes a JSON "enum" of its member values, since those are what the model has to generate+        values = [member.value for member in hint]+        if not values:+            raise TypeHintParsingException(+                f"The Enum {hint.__name__} has no members, so no value could ever match it."+            )+        if any(type(value) not in JSON_SCALAR_TYPES for value in values):+            raise TypeHintParsingException(+                f"The Enum {hint.__name__} has member values that cannot be written as JSON scalars.\n"+                f"Values: {values}\n"+                "Enum member values must be int, float, str, bool or None to be converted to a JSON schema."

Prerender route handlers that await immediatesTypeScript · 142 + / 86 −

Introduces 2 new declarations in packages/next/src/server/route-modules/app-route/module.ts.

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

packages/next/src/server/route-modules/app-route/module.ts ↗ · 15 files

@@ -729,81 +726,140 @@ export class AppRouteRouteModule extends RouteModule<           isFallbackUpgradeable: false,         }) -        let responseHandled = false-        res = await new Promise((resolve, reject) => {-          scheduleImmediate(async () => {-            try {-              const result = await (this.workUnitAsyncStorage.run(-                finalRoutePrerenderStore,-                handler,-                request,-                handlerContext-              ) as Promise<Response>)-              if (responseHandled) {-                // we already rejected in the followup task-                return-              } else if (!(result instanceof Response)) {-                // This is going to error but we let that happen below-                resolve(result)-                return-              }+        const result: {+          status: 'pending-handler' | 'pending-body' | 'complete' | 'failed'+          value: unknown+        } = { status: 'pending-handler', value: undefined }+        const bodyWindow = createPromiseWithResolvers<void>()+        let bodyDeadline: NodeJS.Immediate | undefined+        let waitForBody = false++        function fail(error: unknown) {+          if (+            result.status === 'pending-handler' ||+            result.status === 'pending-body'

Wrap proc-macro `EscapeError` enum into a structRust · 54 + / 39 −

Introduces 9 new declarations in library/proc_macro/src/lib.rs.

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

library/proc_macro/src/lib.rs ↗ · 1 files

@@ -65,10 +65,61 @@ use crate::bridge::client::Methods as BridgeMethods; use crate::escape::{EscapeOptions, escape_bytes};  /// Mostly relating to malformed escape sequences, but also a few other problems.+#[derive(Debug, PartialEq, Eq)]+#[unstable(feature = "proc_macro_value", issue = "136652")]+pub struct EscapeError {+    kind: EscapeErrorKind,+}++#[unstable(feature = "proc_macro_value", issue = "136652")]+impl error::Error for EscapeError {}+ #[unstable(feature = "proc_macro_value", issue = "136652")]+impl fmt::Display for EscapeError {+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+        fmt::Display::fmt(&self.kind, f)+    }+}++#[unstable(feature = "proc_macro_value", issue = "136652")]+#[doc(hidden)]+impl From<rustc_literal_escaper::EscapeError> for EscapeError {+    fn from(value: rustc_literal_escaper::EscapeError) -> Self {+        use rustc_literal_escaper::EscapeError as EE;++        let kind = match value {+            EE::ZeroChars => EscapeErrorKind::ZeroChars,+            EE::MoreThanOneChar => EscapeErrorKind::MoreThanOneChar,+            EE::LoneSlash => EscapeErrorKind::LoneSlash,+            EE::InvalidEscape => EscapeErrorKind::InvalidEscape,+            EE::BareCarriageReturn => EscapeErrorKind::BareCarriageReturn,+            EE::BareCarriageReturnInRawString => EscapeErrorKind::BareCarriageReturnInRawString,+            EE::EscapeOnlyChar => EscapeErrorKind::EscapeOnlyChar,