Aug 20, 2026 – Aug 26, 2026

feat(desktop): clipboard apiRust · 332 + / 3 −

335 source lines changed in cli/rt/desktop.rs.

A reviewable change in a preferred language design path. Focused tests changed with it.

cli/rt/desktop.rs ↗ · 7 files

@@ -696,6 +698,75 @@ pub const DESKTOP_JS: &str = r#"     console.error("[deno desktop] failed to install navigator.permissions:", e);   } +  // --- navigator.clipboard (text only) ---+  //+  // Spec surface: `navigator.clipboard` is a `Clipboard` (extends EventTarget)+  // exposing async `readText()` / `writeText()`. The ops behind them are+  // genuinely async: laufey's clipboard calls block their calling thread, and+  // on X11/Wayland a read is serviced by whichever app owns the selection, so+  // an unresponsive owner would otherwise freeze the whole runtime behind a+  // Promise that looks like it couldn't. They reject rather than resolve if+  // that owner never answers — `""` is indistinguishable from an empty+  // clipboard, and a resolved `writeText()` has to mean the write happened.+  //+  // The richer `read()` / `write()` (`ClipboardItem` / arbitrary MIME types)+  // aren't backed by laufey, so they're omitted rather than stubbed. Per spec+  // the read/write are gated on the `clipboard-read` / `clipboard-write`+  // permissions, but laufey has no clipboard permission model, so access+  // isn't gated here (mirroring how the desktop Notification surface+  // degrades).+  const webidl = internals.webidl;+  class Clipboard extends EventTarget {+    constructor() {+      super();+      webidl.illegalConstructor();+    }++    async readText() {+      webidl.assertBranded(this, ClipboardPrototype);+      return (await op_desktop_read_clipboard_text()) ?? "";+    }++    async writeText(data) {

Fix Turbopack resolution through chained symlinksRust · 135 + / 13 −

148 source lines changed in turbopack/crates/turbo-tasks-fs/src/disk.rs.

A reviewable change in a preferred framework internals path. Focused tests changed with it.

turbopack/crates/turbo-tasks-fs/src/disk.rs ↗ · 8 files

@@ -1958,6 +1958,67 @@ mod tests {             tt.stop_and_wait().await;         } +        #[cfg(unix)]+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]+        async fn test_link_target_resolved_type_through_chain() {+            use std::os::unix::fs::symlink;++            let scratch = tempfile::tempdir().unwrap();+            let path = scratch.path().to_owned();+            create_dir_all(path.join("target-dir")).unwrap();+            File::create_new(path.join("target-file")).unwrap();+            symlink("target-dir", path.join("dir-inner")).unwrap();+            symlink("dir-inner", path.join("dir-outer")).unwrap();+            symlink("target-file", path.join("file-inner")).unwrap();+            symlink("file-inner", path.join("file-outer")).unwrap();+            symlink("../outside", path.join("invalid-inner")).unwrap();+            symlink("invalid-inner", path.join("invalid-outer")).unwrap();++            let root = canonicalize_to_rcstr(&path).unwrap();++            #[turbo_tasks::function(operation, root)]+            async fn assert_operation(+                fs: ResolvedVc<DiskFileSystem>,+                root_path: FileSystemPath,+            ) -> anyhow::Result<()> {+                for (input_path, expected_output) in [+                    ("dir-outer", FileSystemEntryType::Directory),+                    ("file-outer", FileSystemEntryType::File),+                    ("invalid-outer", FileSystemEntryType::Error),+                ] {+                    let link = fs.read_link(root_path.join(input_path)?).await?;+                    let LinkContent::Link { target } = &*link else {

DRA: Fix ExtendedResourceCache handling of DeviceClass collisionsGo · 170 + / 78 −

248 source lines changed in staging/src/k8s.io/dynamic-resource-allocation/deviceclass/extendedresourcecache/extendedresourcecache.go.

A reviewable change in a preferred framework internals path. Focused tests changed with it.

staging/src/k8s.io/dynamic-resource-allocation/deviceclass/extendedresourcecache/extendedresourcecache.go ↗ · 2 files

@@ -134,86 +150,150 @@ func (c *ExtendedResourceCache) OnUpdate(oldObj, newObj interface{}) {  // OnDelete handles deletion of a device class. func (c *ExtendedResourceCache) OnDelete(obj interface{}) {-	if tombstone, ok := obj.(cache.DeletedFinalStateUnknown); ok {-		obj = tombstone.Obj-	}-	deviceClass, ok := obj.(*resourceapi.DeviceClass)-	if !ok {+	// DeltaFIFO.Replace can emit a key-only tombstone with a nil Obj when+	// the key is no longer available from knownObjects.+	// DeletionHandlingObjectToName falls back to the tombstone key in that+	// case, which is enough because DeviceClass is cluster-scoped and all+	// mappings are keyed by class name.+	objName, err := cache.DeletionHandlingObjectToName(obj)+	if err != nil { 		utilruntime.HandleErrorWithLogger(c.logger, nil, "Expected DeviceClass", "actual", fmt.Sprintf("%T", obj)) 		return 	}-	c.logger.V(5).Info("DeviceClass deleted", "deviceClass", klog.KObj(deviceClass))-	c.removeResourceName2class(deviceClass)-	c.removeClass2ResourceName(deviceClass)+	className := objName.Name+	c.logger.V(5).Info("DeviceClass deleted", "deviceClass", className)+	c.removeMappings(className)  	for _, handler := range c.handlers { 		handler.OnDelete(obj) 	} } -// updateResourceName2class updates the cache with the device class mapping.-// It first removes any existing mappings for this device class to handle-// ExtendedResourceName changes, then adds the new mappings.

Revert "[rust-compiler] Bail out on nested TypeScript `this` parameters (#37232)"Rust · 4 + / 12 −

16 source lines changed in compiler/crates/react_compiler_lowering/src/build_hir.rs.

A reviewable change in a preferred language design path. Read the linked PR for the surrounding test context.

compiler/crates/react_compiler_lowering/src/build_hir.rs ↗ · 1 files

@@ -2589,25 +2589,17 @@ fn lower_block_statement(     block: &react_compiler_ast::statements::BlockStatement,     parent_scope: Option<react_compiler_ast::scope::ScopeId>, ) -> Result<(), CompilerError> {-    Ok(lower_block_statement_inner(-        builder,-        block,-        None,-        parent_scope,-    )?)+    let _ = lower_block_statement_inner(builder, block, None, parent_scope);+    Ok(()) }  fn lower_block_statement_with_scope(     builder: &mut HirBuilder,     block: &react_compiler_ast::statements::BlockStatement,     scope_override: react_compiler_ast::scope::ScopeId, ) -> Result<(), CompilerError> {-    Ok(lower_block_statement_inner(-        builder,-        block,-        Some(scope_override),-        None,-    )?)+    let _ = lower_block_statement_inner(builder, block, Some(scope_override), None);+    Ok(()) }  fn lower_block_statement_inner(

perf(ext/websocket): shrink the op_ws_create futureRust · 79 + / 3 −

82 source lines changed in ext/websocket/lib.rs.

A reviewable change in a preferred language design path. Read the linked PR for the surrounding test context.

ext/websocket/lib.rs ↗ · 1 files

@@ -1073,3 +1110,42 @@ where     deno_core::unsync::spawn(fut);   } }++#[cfg(test)]+mod tests {+  use super::*;++  /// Returns the size of the future produced by `f` without constructing any+  /// arguments or running it. `size_of_val` on such a future would require+  /// building an `OpState`, so we measure the (opaque) future type instead.+  fn future_size<F: Future>(_f: impl FnOnce() -> F) -> usize {+    std::mem::size_of::<F>()+  }++  /// `op_ws_create` used to hold a ~16 KB connect/handshake state machine+  /// inline, roughly 30x the p99 async op future. The op driver sizes its+  /// future arena slots off the largest op future, so a single outlier makes+  /// every op more expensive. Keep this one small.+  #[test]+  #[allow(unreachable_code, reason = "the closure is never called")]+  fn op_ws_create_future_is_small() {+    let size = future_size(|| {+      op_ws_create_inner(+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),+        unreachable!(),

llama: add token ID tracking to KV cellC++ · 133 + / 14 −

147 source lines changed in src/llama-kv-cache.cpp.

A reviewable change in a preferred runtime path. Read the linked PR for the surrounding test context.

src/llama-kv-cache.cpp ↗ · 4 files

@@ -1805,6 +1813,69 @@ void llama_kv_cache::set_input_v_rot(ggml_tensor * dst) const {     memcpy(dst->data, attn_rot_hadamard.at(n_rot).data(), ggml_nbytes(dst)); } +bool llama_kv_cache::has_cell_ext() const {+    return hparams.n_pos_per_embd() > 1;+}++void llama_kv_cache::get_prev_tokens(const llama_ubatch & ubatch, uint32_t n, std::vector<llama_token> & res) const {+    const uint32_t n_tokens = ubatch.n_tokens;++    res.clear();+    res.resize(n_tokens*n, LLAMA_TOKEN_NULL);++    if (n == 0) {+        return;+    }++    // note: apply_ubatch() has already stored the current ubatch+    //       the window below thus covers tokens of this very ubatch as well, which is what we want+    llama_pos p_min = std::numeric_limits<llama_pos>::max();+    llama_pos p_max = std::numeric_limits<llama_pos>::min();++    std::bitset<LLAMA_MAX_SEQ> seqs;++    for (uint32_t i = 0; i < n_tokens; ++i) {+        p_min = std::min(p_min, ubatch.pos[i]);+        p_max = std::max(p_max, ubatch.pos[i]);+    }++    for (uint32_t s = 0; s < ubatch.n_seqs_unq; ++s) {+        seqs.set(ubatch.seq_id_unq[s]);+    }+

turbo-tasks: execute scheduled tasks inline when they are readRust · 1024 + / 147 −

1171 source lines changed in turbopack/crates/turbo-tasks/src/priority_runner.rs.

A reviewable change in a preferred framework internals path. Focused tests changed with it.

turbopack/crates/turbo-tasks/src/priority_runner.rs ↗ · 12 files

@@ -336,6 +479,224 @@ mod tests {      use super::*; +    impl Claimable for u32 {+        type Key = u32;++        fn claim_key(&self) -> Option<u32> {+            Some(*self)+        }+    }++    impl Claimable for (u32, bool) {+        type Key = u32;++        fn claim_key(&self) -> Option<u32> {+            Some(self.0)+        }+    }++    /// An item that is never claimable, to check that `None` keys are queued and executed as usual.+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]+    struct Unkeyed(u32);++    impl Claimable for Unkeyed {+        type Key = u32;++        fn claim_key(&self) -> Option<u32> {+            None+        }+    }++    /// An executor that records which items it was asked to execute, in order, and whose futures+    /// complete immediately. Lets the queue be driven without a tokio runtime.

feat(desktop): support checked, icon, and tooltip on menu itemsRust · 87 + / 5 −

92 source lines changed in runtime/ops/desktop.rs.

A reviewable change in a preferred language design path. Read the linked PR for the surrounding test context.

runtime/ops/desktop.rs ↗ · 7 files

@@ -1821,6 +1831,53 @@ mod tests {     }   } +  #[test]+  fn menu_item_wire_shape_new_fields_are_optional() {+    // Pre-existing callers only pass label/enabled (+ optional id and+    // accelerator); checked/icon/tooltip must default rather than error.+    let item: MenuItem = serde_json::from_value(json!({+      "item": { "label": "Save", "enabled": true }+    }))+    .unwrap();+    match item {+      MenuItem::Item {+        checked,+        icon,+        tooltip,+        ..+      } => {+        assert!(!checked);+        assert!(icon.is_none());+        assert!(tooltip.is_none());+      }+      _ => panic!("expected Item"),+    }++    let item: MenuItem = serde_json::from_value(json!({+      "item": {+        "label": "Mute",+        "enabled": true,+        "checked": true,+        "icon": [0x89, 0x50, 0x4E, 0x47],+        "tooltip": "Silence notifications",+      }

metal : per-device tuned (Q, NE) for flash-attn vec (replay)C++ · 1089 + / 0 −

1089 source lines changed in tools/tuning/fa-vec.cpp.

A reviewable change in a preferred runtime path. Focused tests changed with it.

tools/tuning/fa-vec.cpp ↗ · 18 files

@@ -0,0 +1,641 @@+#include "fa-vec.h"++#include "bench.h"+#include "ggml-backend.h"+#include "ggml-metal-tuning.h"+#include "ggml.h"++#include <algorithm>+#include <cmath>+#include <cstdio>+#include <cstring>+#include <random>+#include <set>+#include <string>+#include <vector>++// GQA spec-decode shape: enough query heads to keep the GPU busy so the Q>1 K/V-reuse+// benefit is visible. nh KV heads, nr2 query heads each, nr3 batches.+static const int FA_NH  = 4;+static const int FA_NR2 = 8;+static const int FA_NR3 = 1;++struct fa_shape {+    int       dk;+    int       dv;+    int       ne01;  // query rows+    int       ne11;  // KV length+    ggml_type type_kv;+};++// mirrors test_flash_attn_ext::build_graph for the subset this tuner sweeps+// (mask=true, sinks=false, prec=F32, type_K==type_V, no permute)+static ggml_tensor * fa_build_graph(ggml_context * ctx, const fa_shape & s) {

src: use simdutf for two-byte string utf8 conversion in utf8 valueC++ · 12 + / 5 −

17 source lines changed in src/util.cc.

A reviewable change in a preferred runtime path. Read the linked PR for the surrounding test context.

src/util.cc ↗ · 2 files

@@ -121,13 +121,20 @@ static void MakeUtf8String(Isolate* isolate,     return;   } -  // Add +1 for null termination.-  size_t storage = (3 * value_length) + 1;+  auto const_char16 = reinterpret_cast<const char16_t*>(value_view.data16());+  size_t storage = static_cast<size_t>(value_length) * 3 + 1;   target->AllocateSufficientStorage(storage); -  size_t length = string->WriteUtf8V2(-      isolate, target->out(), storage, String::WriteFlags::kReplaceInvalidUtf8);-  target->SetLengthAndZeroTerminate(length);+  size_t actual_length =+      simdutf::convert_utf16_to_utf8(const_char16, value_length, target->out());+  if (actual_length == 0) {+    actual_length =+        string->WriteUtf8V2(isolate,+                            target->out(),+                            storage,+                            String::WriteFlags::kReplaceInvalidUtf8);+  }+  target->SetLengthAndZeroTerminate(actual_length); }  Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {