helloadhavan/github_issues huggingface dataset:
Repository: ggml-org/llama.cpp
Pull request: llama : use std::abs instead of abs

This replaces use of the global `abs` with `std::abs`.

The `abs` function declared outside of the `std` namespace is not required to have any of the C++ overloads defined. (Although it's also not precluded.)

Under Clang using the global `abs` with a larger integer type gives a truncation warning.

```
/home/kaetemi/llama.cpp/src/llama-quant.cpp:656:66: warning: absolute value function 'abs' given an argument of type 'const int64_t' (aka 'const long') but has parameter of type 'int' which may cause truncation of value [-Wabsolute-value]
  656 |                 gguf_set_val_u32(ctx_out.get(), o.key, (uint32_t)abs(o.val_i64));
      |                                                                  ^
/home/kaetemi/llama.cpp/src/llama-quant.cpp:656:66: note: use function 'std::abs' instead
  656 |                 gguf_set_val_u32(ctx_out.get(), o.key, (uint32_t)abs(o.val_i64));
      |                                                                  ^~~
      |                                                                  std::abs
1 warning generated.
```

Some standard libraries define the overloads globally, some don't. Recommended to always use the `std::` functions to avoid anything unexpected.

See https://github.com/ggml-org/llama.cpp/issues/15374 for further references.

This also was reported in the following issues:
https://github.com/ggml-org/llama.cpp/issues/15044
https://github.com/ggml-org/llama.cpp/issues/15254

This PR replaces the following incorrect PR:
https://github.com/ggml-org/llama.cpp/pull/14209

Changed files:
filename: src/llama-graph.cpp
patch: @@ -2035,7 +2035,7 @@ int32_t llama_relative_position_bucket(llama_pos x, llama_pos y, uint64_t n_buck
 
     if (bidirectional) {
         relative_bucket += (relative_position > 0) * n_buckets;
-        relative_position = abs(relative_position);
+        relative_position = std::abs(relative_position);
     } else {
         relative_position = -std::min<int32_t>(relative_position, 0);
     }

filename: src/llama-quant.cpp
patch: @@ -653,7 +653,7 @@ static void llama_model_quantize_impl(const std::string & fname_inp, const std::
                 gguf_set_val_f32(ctx_out.get(), o.key, o.val_f64);
             } else if (o.tag == LLAMA_KV_OVERRIDE_TYPE_INT) {
                 // Setting type to UINT32. See https://github.com/ggml-org/llama.cpp/pull/14182 for context
-                gguf_set_val_u32(ctx_out.get(), o.key, (uint32_t)abs(o.val_i64));
+                gguf_set_val_u32(ctx_out.get(), o.key, (uint32_t)std::abs(o.val_i64));
             } else if (o.tag == LLAMA_KV_OVERRIDE_TYPE_BOOL) {
                 gguf_set_val_bool(ctx_out.get(), o.key, o.val_bool);
             } else if (o.tag == LLAMA_KV_OVERRIDE_TYPE_STR) {
Repository: vercel/next.js
Pull request: Add special marker in terminal if all error stack frames are ignore-listed

Can be quite confusing when we ignore-list all stackframes in errors. Especially due to the weird formatting Node.js produces. These should be a bit clearer:
<img width="452" height="196" alt="CleanShot 2025-08-22 at 00 27 01@2x" src="https://github.com/user-attachments/assets/680c9779-6a21-4c29-b488-b82095316111" />


The display is inspired by what Chrome does:
<img width="470" height="128" alt="CleanShot 2025-08-22 at 00 26 09@2x" src="https://github.com/user-attachments/assets/f0099772-603a-4343-ae14-67b3ed241dcf" />


We might add a CLI flag to disable ignore-listing in the terminal. But it's a niche use case since errors with only ignore-listed frames are almost always bugs and bugs are generally unactionable beyond reporting. ignore-listing optimizes for our users not framework devs. The best affordance right now to disable ignore-listing is attaching a debugger which you probably need anyway when investigating bugs.

Changed files:
filename: packages/next/src/server/patch-error-inspect.ts
patch: @@ -12,7 +12,7 @@ import {
 import { parseStack, type StackFrame } from './lib/parse-stack'
 import { getOriginalCodeFrame } from '../next-devtools/server/shared'
 import { workUnitAsyncStorage } from './app-render/work-unit-async-storage.external'
-import { dim } from '../lib/picocolors'
+import { dim, italic } from '../lib/picocolors'
 
 type FindSourceMapPayload = (
   sourceURL: string
@@ -416,6 +416,17 @@ function parseAndSourceMap(
     }
   }
 
+  if (sourceMappedStack === '' && sourceMappedFrames.length > 0) {
+    // The `at` marker is important so that Node.js doesn't add square brackets
+    // around the stringified error i.e. this results in
+    // Error: message
+    //   at <ignore-listed frames>
+    // instead of
+    // [Error: message
+    //   at <ignore-listed frames>]
+    sourceMappedStack = '\n    at ' + italic('ignore-listed frames')
+  }
+
   return (
     errorName +
     ': ' +
Repository: ggml-org/llama.cpp
Pull request: vulkan: Handle argsort with a large number of rows

See https://github.com/ggml-org/llama.cpp/pull/16849#issuecomment-3464444262

Changed files:
filename: ggml/src/ggml-vulkan/ggml-vulkan.cpp
patch: @@ -1082,6 +1082,7 @@ struct vk_op_soft_max_push_constants {
 
 struct vk_op_argsort_push_constants {
     uint32_t ncols;
+    uint32_t nrows;
     int32_t order;
 };
 
@@ -8708,6 +8709,7 @@ static void ggml_vk_op_f32(ggml_backend_vk_context * ctx, vk_context& subctx, co
         break;
     case GGML_OP_ARGSORT:
         elements = { (uint32_t)ne00, (uint32_t)ggml_nrows(src0), 1 };
+        elements[1] = std::min(elements[1], ctx->device->properties.limits.maxComputeWorkGroupCount[1]);
         break;
     case GGML_OP_IM2COL:
         {
@@ -9954,9 +9956,11 @@ static void ggml_vk_argsort(ggml_backend_vk_context * ctx, vk_context& subctx, c
     int32_t * op_params = (int32_t *)dst->op_params;
 
     uint32_t ncols = src0->ne[0];
+    uint32_t nrows = ggml_nrows(src0);
 
     ggml_vk_op_f32<vk_op_argsort_push_constants>(ctx, subctx, src0, nullptr, nullptr, nullptr, dst, GGML_OP_ARGSORT, {
         ncols,
+        nrows,
         op_params[0],
     }, dryrun);
 }

filename: ggml/src/ggml-vulkan/vulkan-shaders/argsort.comp
patch: @@ -14,6 +14,7 @@ layout (binding = 1)          buffer D {int data_d[];};
 
 layout (push_constant) uniform parameter {
     uint ncols;
+    uint nrows;
     uint order;
 } p;
 
@@ -26,10 +27,9 @@ void swap(uint idx0, uint idx1) {
     dst_row[idx1] = tmp;
 }
 
-void argsort(bool needs_bounds_check) {
+void argsort(bool needs_bounds_check, const uint row) {
     // bitonic sort
     const int col = int(gl_LocalInvocationID.x);
-    const uint row = gl_WorkGroupID.y;
 
     const uint row_offset = row * p.ncols;
 
@@ -72,8 +72,16 @@ void argsort(bool needs_bounds_check) {
 
 void main() {
     if (p.ncols == BLOCK_SIZE) {
-        argsort(false);
+        uint row = gl_WorkGroupID.y;
+        while (row < p.nrows) {
+            argsort(false, row);
+            row += gl_WorkGroupSize.y * gl_NumWorkGroups.y;
+        }
     } else {
-        argsort(true);
+        uint row = gl_WorkGroupID.y;
+        while (row < p.nrows) {
+            argsort(true, row);
+            row += gl_WorkGroupSize.y * gl_NumWorkGroups.y;
+        }
     }
 }
Repository: huggingface/transformers
Pull request: Fix CI (hunyuan moe does not support fullgraph)

# What does this PR do?



Changed files:
filename: src/transformers/models/hunyuan_v1_moe/modeling_hunyuan_v1_moe.py
patch: @@ -355,8 +355,7 @@ class HunYuanMoEV1PreTrainedModel(PreTrainedModel):
     _supports_flash_attn = True
     _supports_sdpa = True
     _supports_flex_attn = True
-
-    _can_compile_fullgraph = True
+    _can_compile_fullgraph = False
     _supports_attention_backend = True
     _can_record_outputs = {
         "hidden_states": HunYuanMoEV1DecoderLayer,

filename: src/transformers/models/hunyuan_v1_moe/modular_hunyuan_v1_moe.py
patch: @@ -197,6 +197,8 @@ def __init__(self, config: HunYuanMoEV1Config, layer_idx: int):
 
 
 class HunYuanMoEV1PreTrainedModel(LlamaPreTrainedModel):
+    _can_compile_fullgraph = False
+
     def _init_weights(self, module):
         std = self.config.initializer_range
         if isinstance(module, nn.Linear):
Repository: ggml-org/llama.cpp
Pull request: llama: fix ASAN error with M-RoPE

Follow up https://github.com/ggml-org/llama.cpp/pull/16825

I forgot to re-enable ASAN on my build, so I didn't catch this error on the initial PR.


Changed files:
filename: src/llama-batch.cpp
patch: @@ -669,10 +669,8 @@ llama_ubatch llama_batch_allocr::ubatch_add(const std::vector<int32_t> & idxs, u
 
     auto udata = std::make_shared<llama_ubatch::data_t>();
 
-    const int32_t n_pos_cur = batch.embd ? n_pos_per_embd : 1;
-
     const int64_t n_embd_all = batch.embd ? (int64_t) n_tokens*n_embd : 0;
-    const int64_t n_pos_all  =              (int64_t) n_tokens*n_pos_cur;
+    const int64_t n_pos_all  =              (int64_t) n_tokens*n_pos_per_embd;
 
     udata->token     .resize(n_tokens);
     udata->embd      .resize(n_embd_all);
@@ -694,8 +692,13 @@ llama_ubatch llama_batch_allocr::ubatch_add(const std::vector<int32_t> & idxs, u
             memcpy(udata->embd.data() + i*n_embd, batch.embd + (int64_t) idxs[i]*n_embd, n_embd*sizeof(float));
         }
 
-        for (int j = 0; j < n_pos_cur; ++j) {
-            udata->pos[j*n_tokens + i] = batch.pos[j*batch.n_tokens + idxs[i]];
+        for (size_t j = 0; j < (size_t)n_pos_per_embd; ++j) {
+            // if we are using M-RoPE
+            //     if the current batch is text, we need to broadcast the same position across all RoPE sections
+            //     otherwise, the input batch is image embeddings, we copy the positions as-is
+            // if we are not using M-RoPE, there is only one position per token (this loop runs only once)
+            size_t src_off = batch.token ? 0 : j*batch.n_tokens;
+            udata->pos[j*n_tokens + i] = batch.pos[src_off + idxs[i]];
         }
 
         udata->n_seq_id[i] = batch.n_seq_id[idxs[i]];
Repository: nodejs/node
Pull request: deps: patch V8 to 13.7.152.14

This is an automated patch update of V8 to 13.7.152.14.

Changed files:
filename: deps/v8/include/v8-version.h
patch: @@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 13
 #define V8_MINOR_VERSION 7
 #define V8_BUILD_NUMBER 152
-#define V8_PATCH_LEVEL 13
+#define V8_PATCH_LEVEL 14
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

filename: deps/v8/src/wasm/canonical-types.h
patch: @@ -357,7 +357,8 @@ class TypeCanonicalizer {
       const bool indexed = type1.has_index();
       if (indexed != type2.has_index()) return false;
       if (indexed) {
-        return EqualTypeIndex(type1.ref_index(), type2.ref_index());
+        return type1.is_equal_except_index(type2) &&
+               EqualTypeIndex(type1.ref_index(), type2.ref_index());
       }
       return type1 == type2;
     }

filename: deps/v8/src/wasm/value-type.h
patch: @@ -1062,6 +1062,10 @@ class CanonicalValueType : public ValueTypeBase {
     return bit_field_ == other.bit_field_;
   }
 
+  constexpr bool is_equal_except_index(CanonicalValueType other) const {
+    return (bit_field_ & ~kIndexBits) == (other.bit_field_ & ~kIndexBits);
+  }
+
   constexpr bool IsFunctionType() const {
     return ref_type_kind() == RefTypeKind::kFunction;
   }
Repository: vercel/next.js
Pull request: Turbopack: sync NFT context configs

Keep Turbopack's NFT resolve options in sync with the NFT unit tests so that we are actually asserting the production behvior.

Closes PACK-5301

Changed files:
filename: turbopack/crates/turbopack/src/lib.rs
patch: @@ -670,12 +670,13 @@ async fn externals_tracing_module_context(
     compile_time_info: Vc<CompileTimeInfo>,
 ) -> Result<Vc<ModuleAssetContext>> {
     let resolve_options = ResolveOptionsContext {
+        enable_node_native_modules: true,
         emulate_environment: Some(compile_time_info.await?.environment),
         loose_errors: true,
         custom_conditions: match ty {
-            ExternalType::CommonJs => vec![rcstr!("require")],
-            ExternalType::EcmaScriptModule => vec![rcstr!("import")],
-            ExternalType::Url | ExternalType::Global | ExternalType::Script => vec![],
+            ExternalType::CommonJs => vec![rcstr!("require"), rcstr!("node")],
+            ExternalType::EcmaScriptModule => vec![rcstr!("import"), rcstr!("node")],
+            ExternalType::Url | ExternalType::Global | ExternalType::Script => vec![rcstr!("node")],
         },
         ..Default::default()
     };
@@ -688,11 +689,14 @@ async fn externals_tracing_module_context(
         // are actually representative of what Turbopack does.
         ModuleOptionsContext {
             ecmascript: EcmascriptOptionsContext {
+                // enable_types should not be enabled here. It gets set automatically when a TS file
+                // is encountered.
                 source_maps: SourceMapsType::None,
                 ..Default::default()
             },
             css: CssOptionsContext {
                 source_maps: SourceMapsType::None,
+                enable_raw_css: true,
                 ..Default::default()
             },
             // Environment is not passed in order to avoid downleveling JS / CSS for

filename: turbopack/crates/turbopack/tests/node-file-trace.rs
patch: @@ -338,9 +338,10 @@ async fn node_file_trace_operation(
     ));
     let module_asset_context = ModuleAssetContext::new(
         Default::default(),
-        // TODO It's easy to make a mistake here as this should match the config in the
-        // binary. TODO These test cases should move into the
-        // `node-file-trace` crate and use the same config.
+        // TODO These test cases should move into the `node-file-trace` crate and use the same
+        // config.
+        // It's easy to make a mistake here as this should match the config in the binary from
+        // turbopack/crates/turbopack/src/lib.rs
         CompileTimeInfo::new(environment),
         ModuleOptionsContext {
             ecmascript: EcmascriptOptionsContext {
Repository: ollama/ollama
Pull request: check for newer updates

Check if there are newer version of ollama updates available. This prevents multiple updates in a row.

Changed files:
filename: app/src/index.ts
patch: @@ -162,13 +162,43 @@ app.on('before-quit', () => {
   }
 })
 
+let currentReleaseURL = ''
+
+async function isNewReleaseAvailable() {
+  try {
+    const response = await fetch('https://ollama.ai/api/update')
+
+    if (response.status === 204) {
+      return false
+    }
+
+    const data = await response.json()
+
+    if (currentReleaseURL === data.url) {
+      return false
+    }
+
+    currentReleaseURL = data.url
+    return true
+  } catch (error) {
+    logger.error(`update check failed - ${error}`)
+    return false
+  }
+}
+
+async function checkUpdate() {
+  const available = await isNewReleaseAvailable()
+  if (available) {
+    logger.info('checking for update')
+    autoUpdater.checkForUpdates()
+  }
+}
+
 function init() {
   if (app.isPackaged) {
-    autoUpdater.checkForUpdates()
+    checkUpdate()
     setInterval(() => {
-      if (!updateAvailable) {
-        autoUpdater.checkForUpdates()
-      }
+      checkUpdate()
     }, 60 * 60 * 1000)
   }
Repository: denoland/deno
Pull request: test: use longer timeout in netTcpWithAbortSignal test

This test has been very flaky on Windows CI recently.

Changed files:
filename: tests/unit/net_test.ts
patch: @@ -1290,7 +1290,7 @@ Deno.test(
   { permissions: { net: true } },
   async function netTcpWithAbortSignal() {
     const controller = new AbortController();
-    setTimeout(() => controller.abort(), 100);
+    setTimeout(() => controller.abort(), 1_000);
     const error = await assertRejects(
       async () => {
         await Deno.connect({
Repository: denoland/deno
Pull request: fix(ext/node): make `fs.glob` accepts `URL` cwd

Towards #29972

Allows https://github.com/nodejs/node/blob/v24.2.0/test/parallel/test-fs-glob.mjs to pass.

Changed files:
filename: ext/node/polyfills/_fs/_fs_glob.ts
patch: @@ -42,6 +42,7 @@ import {
 import assert from "node:assert";
 
 import type { ErrnoException } from "ext:deno_node/_global.d.ts";
+import { toPathIfFileURL } from "ext:deno_node/internal/url.ts";
 
 interface GlobOptionsBase {
   /**
@@ -336,7 +337,7 @@ export class Glob {
   constructor(pattern, options = kEmptyObject) {
     validateObject(options, "options");
     const { exclude, cwd, withFileTypes } = options;
-    this.#root = cwd ?? ".";
+    this.#root = toPathIfFileURL(cwd) ?? ".";
     this.#withFileTypes = !!withFileTypes;
     if (exclude != null) {
       validateStringArrayOrFunction(exclude, "options.exclude");

filename: tests/node_compat/config.toml
patch: @@ -436,6 +436,7 @@
 "parallel/test-fs-existssync-false.js" = {}
 "parallel/test-fs-fchown.js" = {}
 "parallel/test-fs-fsync.js" = {}
+"parallel/test-fs-glob.mjs" = {}
 "parallel/test-fs-internal-assertencoding.js" = {}
 "parallel/test-fs-link.js" = { flaky = true }
 "parallel/test-fs-long-path.js" = {}
Repository: nodejs/node
Pull request: test: reduce the use of private symbols in test-events-once.js

This PR reduces the usage of private symbol `kEvents` in `test/parallel/test-events-once.js`.

It'd be good to avoid using private items to make future refactoring easier

Changed files:
filename: test/parallel/test-events-once.js
patch: @@ -1,15 +1,14 @@
 'use strict';
-// Flags: --expose-internals --no-warnings
+// Flags: --no-warnings
 
 const common = require('../common');
-const { once, EventEmitter } = require('events');
+const { once, EventEmitter, getEventListeners } = require('events');
 const {
   deepStrictEqual,
   fail,
   rejects,
   strictEqual,
 } = require('assert');
-const { kEvents } = require('internal/event_target');
 
 async function onceAnEvent() {
   const ee = new EventEmitter();
@@ -78,7 +77,7 @@ async function catchesErrorsWithAbortSignal() {
   try {
     const promise = once(ee, 'myevent', { signal });
     strictEqual(ee.listenerCount('error'), 1);
-    strictEqual(signal[kEvents].size, 1);
+    strictEqual(getEventListeners(signal, 'abort').length, 1);
 
     await promise;
   } catch (e) {
@@ -87,7 +86,7 @@ async function catchesErrorsWithAbortSignal() {
   strictEqual(err, expected);
   strictEqual(ee.listenerCount('error'), 0);
   strictEqual(ee.listenerCount('myevent'), 0);
-  strictEqual(signal[kEvents].size, 0);
+  strictEqual(getEventListeners(signal, 'abort').length, 0);
 }
 
 async function stopListeningAfterCatchingError() {
@@ -198,9 +197,9 @@ async function abortSignalAfterEvent() {
     ac.abort();
   });
   const promise = once(ee, 'foo', { signal: ac.signal });
-  strictEqual(ac.signal[kEvents].size, 1);
+  strictEqual(getEventListeners(ac.signal, 'abort').length, 1);
   await promise;
-  strictEqual(ac.signal[kEvents].size, 0);
+  strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
 }
 
 async function abortSignalRemoveListener() {
Repository: ollama/ollama
Pull request: improve vram safety with 5% vram memory buffer

In testing how much VRAM should be allocated we typically used a model which could be entirely loaded into VRAM. This masked an issue when a model is larger than the available VRAM it is possible to consume all available VRAM and fail with an error:
```
Error: llama runner failed: out of memory
```

This change leaves a 10% buffer on available VRAM to prevent running out of memory.

Tested on a T4:
- `llama2:7b`: easily offloads all layers to GPU
- `llama2:13b`: easily offloads all layers to GPU
- `llama2:70b`: offloaded 29 layers to GPU, was slow but did not run out of memory on load (as it did before)


Resolves #725

Changed files:
filename: llm/llama.go
patch: @@ -191,15 +191,15 @@ var errNoGPU = errors.New("nvidia-smi command failed")
 
 // CheckVRAM returns the available VRAM in MiB on Linux machines with NVIDIA GPUs
 func CheckVRAM() (int64, error) {
-	cmd := exec.Command("nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits")
+	cmd := exec.Command("nvidia-smi", "--query-gpu=memory.free", "--format=csv,noheader,nounits")
 	var stdout bytes.Buffer
 	cmd.Stdout = &stdout
 	err := cmd.Run()
 	if err != nil {
 		return 0, errNoGPU
 	}
 
-	var total int64
+	var free int64
 	scanner := bufio.NewScanner(&stdout)
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -208,10 +208,10 @@ func CheckVRAM() (int64, error) {
 			return 0, fmt.Errorf("failed to parse available VRAM: %v", err)
 		}
 
-		total += vram
+		free += vram
 	}
 
-	return total, nil
+	return free, nil
 }
 
 func NumGPU(numLayer, fileSizeBytes int64, opts api.Options) int {
@@ -228,14 +228,14 @@ func NumGPU(numLayer, fileSizeBytes int64, opts api.Options) int {
 			return 0
 		}
 
-		totalVramBytes := int64(vramMib) * 1024 * 1024 // 1 MiB = 1024^2 bytes
+		freeVramBytes := int64(vramMib) * 1024 * 1024 // 1 MiB = 1024^2 bytes
 
 		// Calculate bytes per layer
 		// TODO: this is a rough heuristic, better would be to calculate this based on number of layers and context size
 		bytesPerLayer := fileSizeBytes / numLayer
 
-		// max number of layers we can fit in VRAM
-		layers := int(totalVramBytes / bytesPerLayer)
+		// max number of layers we can fit in VRAM, subtract 5% to prevent consuming all available VRAM and running out of memory
+		layers := int(freeVramBytes/bytesPerLayer) * 95 / 100
 		log.Printf("%d MiB VRAM available, loading up to %d GPU layers", vramMib, layers)
 
 		return layers
@@ -367,7 +367,13 @@ func waitForServer(llm *llama) error {
 }
 
 func (llm *llama) Close() {
+	// signal the sub-process to terminate
 	llm.Cancel()
+
+	// wait for the command to exit to prevent race conditions with the next run
+	if err := llm.Cmd.Wait(); err != nil {
+		log.Printf("llama runner exited: %v", err)
+	}
 }
 
 func (llm *llama) SetOptions(opts api.Options) {
Repository: facebook/react
Pull request: Attempt to fix diff syncing for Meta

#28796 broke Meta's PR syncing tool, hoping this fixes it

Changed files:
filename: .github/workflows/commit_artifacts.yml
patch: @@ -132,7 +132,7 @@ jobs:
             ./compiled/facebook-www/eslint-plugin-react-hooks.js
 
           # Move unstable_server-external-runtime.js into facebook-www
-          mv build/oss-stable/react-dom/unstable_server-external-runtime.js \
+          mv build/oss-experimental/react-dom/unstable_server-external-runtime.js \
             ./compiled/facebook-www/unstable_server-external-runtime.js
 
           # Move react-refresh-babel.development.js into babel-plugin-react-refresh
Repository: facebook/react
Pull request: [Fizz] Stop publishing external-runtime to stable channel

The external runtime is not vetted for stability yet. We should stop publishing it with our stable build

Changed files:
filename: packages/shared/ReactFeatureFlags.js
patch: @@ -110,7 +110,7 @@ export const enableUseEffectEventHook = __EXPERIMENTAL__;
 // Test in www before enabling in open source.
 // Enables DOM-server to stream its instruction set as data-attributes
 // (handled with an MutationObserver) instead of inline-scripts
-export const enableFizzExternalRuntime = true;
+export const enableFizzExternalRuntime = __EXPERIMENTAL__;
 
 export const alwaysThrottleRetries = true;
 

filename: scripts/rollup/bundles.js
patch: @@ -328,7 +328,7 @@ const bundles = [
 
   /******* React DOM Fizz Server External Runtime *******/
   {
-    bundleTypes: [BROWSER_SCRIPT],
+    bundleTypes: __EXPERIMENTAL__ ? [BROWSER_SCRIPT] : [],
     moduleType: RENDERER,
     entry: 'react-dom/unstable_server-external-runtime',
     outputPath: 'unstable_server-external-runtime.js',

filename: scripts/rollup/packaging.js
patch: @@ -235,7 +235,14 @@ function filterOutEntrypoints(name) {
       // Let's remove it.
       files.splice(i, 1);
       i--;
-      unlinkSync(`build/node_modules/${name}/${filename}`);
+      try {
+        unlinkSync(`build/node_modules/${name}/${filename}`);
+      } catch (err) {
+        // If the file doesn't exist we can just move on. Otherwise throw the halt the build
+        if (err.code !== 'ENOENT') {
+          throw err;
+        }
+      }
       changed = true;
       // Remove it from the exports field too if it exists.
       if (exportsJSON) {