Oct 20, 2026

Turbopack: propagate late partial namespace provenance to passthrough targetsRust · 277 + / 6 −

Introduces 25 new declarations in turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs.

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

turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs ↗ · 8 files

@@ -513,3 +520,267 @@ mod tests {         assert!(matches!(usage, ModuleExportUsageInfo::All));     } }++#[cfg(test)]+mod graph_tests {+    use anyhow::Result;+    use rustc_hash::FxHashMap;+    use turbo_rcstr::{RcStr, rcstr};+    use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};+    use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage};+    use turbo_tasks_fs::{FileSystem, FileSystemPath, VirtualFileSystem};++    use super::compute_binding_usage_info;+    use crate::{+        asset::{Asset, AssetContent},+        ident::AssetIdent,+        module::{Module, ModuleSideEffects},+        module_graph::{+            GraphEntries, ModuleGraph, SingleModuleGraph,+            chunk_group_info::{ChunkGroupEntry, EntryHeuristics},+        },+        reference::{ModuleReference, ModuleReferences, SingleChunkableModuleReference},+        resolve::ExportUsage,+    };++    /// Module name -> outgoing edges `(target name, export usage of the edge)`, in reference order.+    type Edges = Vec<(RcStr, Vec<(RcStr, ExportUsage)>)>;++    #[turbo_tasks::value(shared)]+    struct UsageTestRepo {+        edges: FxHashMap<RcStr, Vec<(RcStr, ExportUsage)>>,+    }

Only disable the compiler on the offload path in AlignDevicesHookPython · 64 + / 58 −

Introduces 9 new declarations in src/accelerate/hooks.py.

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

src/accelerate/hooks.py ↗ · 2 files

@@ -356,76 +356,82 @@ def _maybe_get_fp16_statistics(self, name, value):         return None      @_compiler_disable-    def pre_forward(self, module, *args, **kwargs):-        if self.io_same_device:-            self.input_device = find_device([args, kwargs])-        if self.offload:-            self.tied_pointers_to_remove = set()+    def _onload_weights(self, module):+        self.tied_pointers_to_remove = set() -            for name, _ in named_module_tensors(-                module,-                include_buffers=self.offload_buffers,-                recurse=self.place_submodules,-                remove_non_persistent=True,+        for name, _ in named_module_tensors(+            module,+            include_buffers=self.offload_buffers,+            recurse=self.place_submodules,+            remove_non_persistent=True,+        ):+            value = self.weights_map[name]+            fp16_statistics = self._maybe_get_fp16_statistics(name, value)++            # In case we are using offloading with tied weights, we need to keep track of the offloaded weights+            # that are loaded on device at this point, as we will need to remove them as well from the dictionary+            # self.tied_params_map in order to allow to free memory.+            if name in self.tied_params_names and value.data_ptr() not in self.tied_params_map:+                self.tied_params_map[value.data_ptr()] = {}++            if (+                value is not None

Align non-recursive responses between cacher and etcdGo · 72 + / 167 −

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

@@ -1516,64 +1498,34 @@ func RunTestNamespaceScopedWatch(ctx context.Context, t *testing.T, store storag 			name:          "namespaced watch, non-recursive, request without name, request without namespace, without field selector", 			recursive:     false, 			fieldSelector: fields.Everything(),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{-						{baseNamespacedPod("t43-foo1", "t43-ns1"), true, watch.Added},-						{baseNamespacedPod("t43-foo2", "t43-ns2"), true, watch.Added},-						{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), true, watch.Modified},-						{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), true, watch.Modified},-					}-				}-				return []*testWatchStruct{-					{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},-					{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},-					{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},-				}-			}(),+			watchTests: []*testWatchStruct{+				{baseNamespacedPod("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPod("t43-foo2", "t43-ns2"), false, ""},+				{baseNamespacedPodUpdated("t43-foo1", "t43-ns1"), false, ""},+				{baseNamespacedPodUpdated("t43-foo2", "t43-ns2"), false, ""},+			}, 		}, 		{ 			name:          "namespaced watch, non-recursive, request without name, request without namespace, field selector with metadata.namespace", 			recursive:     false, 			fieldSelector: fields.ParseSelectorOrDie("metadata.namespace=t44-ns1"),-			watchTests: func() []*testWatchStruct {-				if isWatchCache {-					return []*testWatchStruct{

fix(core): keep op contexts alive until the isolate is disposedRust · 105 + / 12 −

Introduces 4 new declarations in cli/tools/lint/plugins.rs.

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

cli/tools/lint/plugins.rs ↗ · 11 files

@@ -103,6 +103,53 @@ v8_static_strings! { pub struct PluginHostProxy {   tx: mpsc::Sender<PluginHostRequest>,   pub(crate) plugin_info: Arc<Mutex<Vec<PluginInfo>>>,+  // Must be declared after `tx`: fields are dropped in declaration order, and+  // the plugin host's run loop only ends once `tx` has been dropped.+  _thread: PluginHostThread,+}++/// How long dropping a [`PluginHostProxy`] waits for the plugin host to tear+/// down its worker. Teardown normally takes milliseconds; the bound only+/// guarantees that `deno lint` can never hang on it.+const PLUGIN_HOST_TEARDOWN_TIMEOUT: std::time::Duration =+  std::time::Duration::from_secs(10);++/// The thread running the [`PluginHost`].+///+/// On drop, waits until the plugin host has torn down its worker, and with it+/// the V8 isolate. Without this the thread was detached, so the process could+/// exit while V8 was still disposing of the isolate on that thread.+#[derive(Debug)]+struct PluginHostThread {+  join_handle: Option<std::thread::JoinHandle<Result<(), AnyError>>>,+  /// Disconnected once the plugin host future, and the worker it owns, have+  /// been dropped. (In a `Mutex` only because `PluginHostProxy` is `Sync`.)+  worker_dropped_rx: Mutex<std::sync::mpsc::Receiver<()>>,+}++impl Drop for PluginHostThread {+  fn drop(&mut self) {+    match self+      .worker_dropped_rx+      .get_mut()+      .recv_timeout(PLUGIN_HOST_TEARDOWN_TIMEOUT)

Fix BLOOM crash with static cache / compiled generatePython · 43 + / 52 −

Introduces 2 new declarations in src/transformers/models/bloom/modeling_bloom.py.

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

src/transformers/models/bloom/modeling_bloom.py ↗ · 2 files

@@ -571,40 +580,22 @@ def __init__(self, config: BloomConfig):     def set_output_embeddings(self, new_embeddings: torch.Tensor):         self.lm_head = new_embeddings -    def prepare_inputs_for_generation(+    def create_masks_for_generate(         self,-        input_ids,-        past_key_values=None,-        attention_mask=None,-        inputs_embeds=None,-        use_cache=True,-        is_first_iteration=False,+        config: BloomConfig,+        inputs_embeds: torch.Tensor,+        attention_mask: torch.Tensor | None,+        past_key_values: Cache | None,         **kwargs,-    ):-        # Overwritten because of the fixed-shape attention mask creation--        model_inputs = super().prepare_inputs_for_generation(-            input_ids,-            past_key_values=past_key_values,-            attention_mask=attention_mask,-            inputs_embeds=inputs_embeds,-            use_cache=use_cache,-            is_first_iteration=is_first_iteration,-            **kwargs,-        )--        # This part differs from other models because BLOOM needs a 2D mask to construct alibi tensor-        # The only difference is the usage of 2D instead of 4D mask, but the shape will be static-        if isinstance(past_key_values, StaticCache) and attention_mask is not None: