BUN_JSC_immutableGlobals: one switch that makes every built-in immutable

scripts/build/deps/webkit.ts

@@ -3,7 +3,7 @@
  * for local mode. Override via `--webkit-version=<hash>` to test a branch.
  * From https://github.com/oven-sh/WebKit releases.
  */
-export const WEBKIT_VERSION = "274ebb3cf6008f627197d818e3939d1e2bfc514d";
+export const WEBKIT_VERSION = "autobuild-preview-pr-797-8b82f3fc";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

src/codegen/bindgen-emit.ts

@@ -431,7 +431,7 @@ ${namespace.functions
       `    object->putDirectNativeFunction(vm, globalObject, JSC::Identifier::fromString(vm, ${asciiLiteral(fn.name)}), ${fn.length}, ${hostFunctionName(fn)}, JSC::ImplementationVisibility::Public, JSC::NoIntrinsic, 0);`,
   )
   .join("\n")}
-    return object;
+    return Bun::namespaceObjectOf(vm, owner, object);
 }
 }
 `;
@@ -951,6 +951,7 @@ export function cppSource(file: SchemaFile): string {
   headers.delete(`Generated${file.origin.namespace}.h`);
   const accepted = file.types.filter(type => type instanceof DictionaryType && type.accepted) as DictionaryType[];
   if (accepted.length > 0) headers.add("Bindgen/DictionaryMemberReader.h");
+  if (file.namespaces.length > 0) headers.add("BunClientData.h");
   const systemHeaders = ["JavaScriptCore/JSFunction.h"];
   if (accepted.some(type => !type.allowArray)) systemHeaders.unshift("JavaScriptCore/ArrayConstructor.h");
   if (file.namespaces.length > 0) systemHeaders.push("JavaScriptCore/ObjectConstructor.h");

src/js/builtins/BunBuiltinNames.h

@@ -55,6 +55,7 @@ using namespace JSC;
     macro(close) \
     macro(cmd) \
     macro(code) \
+    macro(consoleAsyncIterator) \
     macro(createCommonJSModule) \
     macro(createFIFO) \
     macro(createInternalModuleById) \

src/js/builtins/ConsoleObject.ts

@@ -1,6 +1,10 @@
 $overriddenName = "[Symbol.asyncIterator]";
 export function asyncIterator(this: Console) {
-  var stream = Bun.stdin.stream();
+  const stdin = Bun.stdin as typeof Bun.stdin & { $consoleAsyncIterator: (() => AsyncGenerator<string>) | undefined };
+  const existing = $getByIdDirectPrivate(stdin, "consoleAsyncIterator");
+  if (existing) return existing();
+
+  var stream = stdin.stream();
 
   var decoder = new TextDecoder("utf-8", { fatal: false });
   var indexOf = Bun.indexOfLine;
@@ -110,23 +114,23 @@ export function asyncIterator(this: Console) {
     }
   }
 
-  const symbol = globalThis.Symbol.asyncIterator;
-  this[symbol] = ConsoleAsyncIterator;
+  $putByIdDirectPrivate(stdin, "consoleAsyncIterator", ConsoleAsyncIterator);
   return ConsoleAsyncIterator();
 }
 
 interface ConsoleWriter extends Bun.FileSink {
   flush(wait?: boolean): number | Promise<number>;
 }
 
-export function write(this: Console & { $writer: ConsoleWriter | undefined }, input) {
+export function write(this: Console, input) {
   if (!$isObject(this)) throw $ERR_INVALID_THIS("Console");
 
-  var writer = $getByIdDirectPrivate(this, "writer");
+  const stdout = Bun.stdout as typeof Bun.stdout & { $writer: ConsoleWriter | undefined };
+  var writer = $getByIdDirectPrivate(stdout, "writer");
   if (!writer) {
     var length = $toLength(input?.length ?? 0);
-    writer = Bun.stdout.writer({ highWaterMark: length > 65536 ? length : 65536 });
-    $putByIdDirectPrivate(this, "writer", writer);
+    writer = stdout.writer({ highWaterMark: length > 65536 ? length : 65536 });
+    $putByIdDirectPrivate(stdout, "writer", writer);
   }
 
   var wrote = writer.write(input) as number;

src/js/bun/ffi.ts

@@ -75,9 +75,10 @@ const nativeDLOpen = ffi.dlopen;
 const nativeCallback = ffi.callback;
 const closeCallback = ffi.closeCallback;
 const nativeCFunction = ffi.cfunction;
-delete ffi.callback;
-delete ffi.closeCallback;
-delete ffi.cfunction;
+const { deleteBuiltinProperty } = require("internal/shared");
+deleteBuiltinProperty(ffi, "callback");
+deleteBuiltinProperty(ffi, "closeCallback");
+deleteBuiltinProperty(ffi, "cfunction");
 
 class JSCallback {
   declare readonly ptr: number | null;

src/js/internal/assert/assertion_error.ts

@@ -4,6 +4,7 @@ const { SafeSet } = require("internal/primordials");
 const { inspect } = require("internal/util/inspect");
 const colors = require("internal/util/colors");
 const { validateObject } = require("internal/validators");
+const { setStackTraceLimitOverride } = require("internal/shared");
 const { printMyersDiff, printSimpleMyersDiff } = require("internal/assert/myers_diff") as typeof Internal;
 
 const ErrorCaptureStackTrace = Error.captureStackTrace;
@@ -274,103 +275,103 @@ class AssertionError extends Error {
     } = options;
     let { actual, expected } = options;
 
-    // NOTE: stack trace is always writable.
-    const limit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 0;
-
-    if (message != null) {
-      if (kMethodsWithCustomMessageDiff.has(operator)) {
-        super(createErrDiff(actual, expected, operator, message, diff));
+    // No frames for this error, which captures its own below, or for one made while the message is rendered.
+    const previousOverride = setStackTraceLimitOverride(0);
+    try {
+      if (message != null) {
+        if (kMethodsWithCustomMessageDiff.has(operator)) {
+          super(createErrDiff(actual, expected, operator, message, diff));
+        } else {
+          super(String(message));
+        }
       } else {
-        super(String(message));
-      }
-    } else {
-      // Reset colors on each call to make sure we handle dynamically set environment
-      // variables correct.
-      colors.refresh();
-      // Prevent the error stack from being visible by duplicating the error
-      // in a very close way to the original in case both sides are actually
-      // instances of Error.
-      if (
-        typeof actual === "object" &&
-        actual !== null &&
-        typeof expected === "object" &&
-        expected !== null &&
-        "stack" in actual &&
-        actual instanceof Error &&
-        "stack" in expected &&
-        expected instanceof Error
-      ) {
-        actual = copyError(actual);
-        expected = copyError(expected);
-      }
-
-      if (kMethodsWithCustomMessageDiff.has(operator)) {
-        super(createErrDiff(actual, expected, operator, message, diff));
-      } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
-        // In case the objects are equal but the operator requires unequal, show
-        // the first object and say A equals B
-        let base = kReadableOperator[operator];
-        const res = StringPrototypeSplit.$call(inspectValue(actual), "\n");
-
-        // In case "actual" is an object or a function, it should not be
-        // reference equal.
+        // Reset colors on each call to make sure we handle dynamically set environment
+        // variables correct.
+        colors.refresh();
+        // Prevent the error stack from being visible by duplicating the error
+        // in a very close way to the original in case both sides are actually
+        // instances of Error.
         if (
-          operator === "notStrictEqual" &&
-          ((typeof actual === "object" && actual !== null) || typeof actual === "function")
+          typeof actual === "object" &&
+          actual !== null &&
+          typeof expected === "object" &&
+          expected !== null &&
+          "stack" in actual &&
+          actual instanceof Error &&
+          "stack" in expected &&
+          expected instanceof Error
         ) {
-          base = kReadableOperator.notStrictEqualObject;
+          actual = copyError(actual);
+          expected = copyError(expected);
         }
 
-        // Only remove lines in case it makes sense to collapse those.
-        const resLength = res.length;
-        if (resLength > 50 && diff !== "full") {
-          res[46] = `${colors.blue}...${colors.white}`;
-          while (res.length > 47) {
-            ArrayPrototypePop.$call(res);
+        if (kMethodsWithCustomMessageDiff.has(operator)) {
+          super(createErrDiff(actual, expected, operator, message, diff));
+        } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+          // In case the objects are equal but the operator requires unequal, show
+          // the first object and say A equals B
+          let base = kReadableOperator[operator];
+          const res = StringPrototypeSplit.$call(inspectValue(actual), "\n");
+
+          // In case "actual" is an object or a function, it should not be
+          // reference equal.
+          if (
+            operator === "notStrictEqual" &&
+            ((typeof actual === "object" && actual !== null) || typeof actual === "function")
+          ) {
+            base = kReadableOperator.notStrictEqualObject;
           }
-        }
 
-        // Only print a single input.
-        if (res.length === 1) {
-          super(`${base}${res[0].length > 5 ? "\n\n" : " "}${res[0]}`);
-        } else {
-          super(`${base}\n\n${ArrayPrototypeJoin.$call(res, "\n")}\n`);
-        }
-      } else {
-        let res = inspectValue(actual);
-        let other = inspectValue(expected);
-        const knownOperator = kReadableOperator[operator];
-        if (operator === "notDeepEqual" && res === other) {
-          res = `${knownOperator}\n\n${res}`;
-          if (res.length > 1024 && diff !== "full") {
-            res = `${StringPrototypeSlice.$call(res, 0, 1021)}...`;
-          }
-          super(res);
-        } else {
-          if (res.length > kMaxLongStringLength && diff !== "full") {
-            res = `${StringPrototypeSlice.$call(res, 0, 509)}...`;
+          // Only remove lines in case it makes sense to collapse those.
+          const resLength = res.length;
+          if (resLength > 50 && diff !== "full") {
+            res[46] = `${colors.blue}...${colors.white}`;
+            while (res.length > 47) {
+              ArrayPrototypePop.$call(res);
+            }
           }
-          if (other.length > kMaxLongStringLength && diff !== "full") {
-            other = `${StringPrototypeSlice.$call(other, 0, 509)}...`;
+
+          // Only print a single input.
+          if (res.length === 1) {
+            super(`${base}${res[0].length > 5 ? "\n\n" : " "}${res[0]}`);
+          } else {
+            super(`${base}\n\n${ArrayPrototypeJoin.$call(res, "\n")}\n`);
           }
-          if (operator === "deepEqual") {
-            res = `${knownOperator}\n\n${res}\n\nshould loosely deep-equal\n\n`;
+        } else {
+          let res = inspectValue(actual);
+          let other = inspectValue(expected);
+          const knownOperator = kReadableOperator[operator];
+          if (operator === "notDeepEqual" && res === other) {
+            res = `${knownOperator}\n\n${res}`;
+            if (res.length > 1024 && diff !== "full") {
+              res = `${StringPrototypeSlice.$call(res, 0, 1021)}...`;
+            }
+            super(res);
           } else {
-            const newOp = kReadableOperator[`${operator}Unequal`];
-            if (newOp) {
-              res = `${newOp}\n\n${res}\n\nshould not loosely deep-equal\n\n`;
+            if (res.length > kMaxLongStringLength && diff !== "full") {
+              res = `${StringPrototypeSlice.$call(res, 0, 509)}...`;
+            }
+            if (other.length > kMaxLongStringLength && diff !== "full") {
+              other = `${StringPrototypeSlice.$call(other, 0, 509)}...`;
+            }
+            if (operator === "deepEqual") {
+              res = `${knownOperator}\n\n${res}\n\nshould loosely deep-equal\n\n`;
             } else {
-              other = ` ${operator} ${other}`;
+              const newOp = kReadableOperator[`${operator}Unequal`];
+              if (newOp) {
+                res = `${newOp}\n\n${res}\n\nshould not loosely deep-equal\n\n`;
+              } else {
+                other = ` ${operator} ${other}`;
+              }
             }
+            super(`${res}${other}`);
           }
-          super(`${res}${other}`);
         }
       }
+    } finally {
+      setStackTraceLimitOverride(previousOverride);
     }
 
-    Error.stackTraceLimit = limit;
-
     this.generatedMessage = !message;
     ObjectDefineProperty(this, "name", {
       __proto__: null,

src/js/internal/cluster/child.ts

@@ -3,7 +3,7 @@ import type { ClusterWorker } from "internal/cluster/Worker";
 const EventEmitter = require("node:events");
 const Worker = require("internal/cluster/Worker");
 const path = require("node:path");
-const { kClusterOwner: owner_symbol, kInternalSendOptions } = require("internal/shared");
+const { kClusterOwner: owner_symbol, kInternalSendOptions, defineBuiltinProperty } = require("internal/shared");
 
 const onInternalMessage = $bindgen("node_cluster_binding.bind.ts", "onInternalMessageChild");
 const closeRawHandle = $bindgen("node_cluster_binding.bind.ts", "clusterCloseHandle");
@@ -74,7 +74,13 @@ cluster._setupWorker = function () {
   // before calling, check if the channel is refd. if it isn't, then unref it after calling process.once();
   $bindgen("node_cluster_binding.bind.ts", "channelIgnoreOneDisconnectEventListener")();
   process.once("disconnect", () => {
-    (process as { channel: unknown }).channel = null;
+    defineBuiltinProperty(process, "channel", {
+      __proto__: null,
+      value: null,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
     worker.emit("disconnect");
 
     if (!worker.exitedAfterDisconnect) {

src/js/internal/process/pre_execution.ts

@@ -4,6 +4,8 @@
 // file, worker, or `-e` eval — is evaluated. Must stay cheap: one execArgv
 // scan, bail early when nothing applies.
 
+const { defineBuiltinProperty, setStackTraceLimitOverride } = require("internal/shared");
+
 let writeSync: typeof import("node:fs").writeSync;
 let envTracePrintMessage = false;
 let envTracePrintJsStack = false;
@@ -126,10 +128,13 @@ function printEnvTrace(kind: EnvOpKind, key: string | null): void {
       // The capture burns 3 frames on trace machinery (printEnvTrace, the
       // proxy trap, and the Error line); widen the limit so the user still
       // sees `Error.stackTraceLimit` real frames.
-      const limit = Error.stackTraceLimit;
-      Error.stackTraceLimit = limit + 3;
-      const stack = new Error().stack!.split("\n");
-      Error.stackTraceLimit = limit;
+      const previousOverride = setStackTraceLimitOverride(Error.stackTraceLimit + 3);
+      let stack: string[];
+      try {
+        stack = new Error().stack!.split("\n");
+      } finally {
+        setStackTraceLimitOverride(previousOverride);
+      }
       // stack[0] = "Error", [1] = printEnvTrace, [2] = the proxy trap.
       let corrected = false;
       for (let i = 3; i < stack.length; i++) {
@@ -196,7 +201,7 @@ function installEnvTracing(): void {
       return ReflectOwnKeys(target);
     },
   });
-  Object.defineProperty(process, "env", {
+  defineBuiltinProperty(process, "env", {
     value: proxy,
     writable: true,
     enumerable: true,
@@ -250,7 +255,7 @@ function installExitTracing(): void {
     writeStderr(out);
     return realExit.$call(process, code);
   }
-  process.exit = exit as typeof process.exit;
+  defineBuiltinProperty(process, "exit", { __proto__: null, value: exit });
 }
 
 {
@@ -297,7 +302,7 @@ function installExitTracing(): void {
 
   if (stackTraceLimit !== null) {
     const limit = Number(stackTraceLimit);
-    if (Number.isFinite(limit)) Error.stackTraceLimit = limit;
+    if (Number.isFinite(limit)) defineBuiltinProperty(Error, "stackTraceLimit", { __proto__: null, value: limit });
   }
 
   // CLI-driven tracing runs in worker VMs too (workers inherit the parent's

src/js/internal/quic/quic.ts

@@ -36,7 +36,8 @@ const {
   isSharedArrayBuffer,
   isKeyObject,
 } = require("node:util/types");
-const { SocketAddress, BlockList } = require("node:net");
+const SocketAddress = $rust("node_net_binding.rs", "SocketAddress");
+const BlockList = $rust("node_net_binding.rs", "BlockList");
 
 // The native binding hands certificates over as DER bytes; expose them as
 // X509Certificate objects like Node does.
@@ -147,16 +148,17 @@ function ERR_QUIC_VERSION_NEGOTIATION_ERROR() {
 const kClientHttp = Symbol("kClientHttp");
 const kNoteClientHttp = Symbol("kNoteClientHttp");
 
+const { defineBuiltinProperty } = require("internal/shared");
 const kSocketAddressHandle = Symbol("kSocketAddressHandle");
-Object.defineProperty(SocketAddress.prototype, kSocketAddressHandle, {
+defineBuiltinProperty(SocketAddress.prototype, kSocketAddressHandle, {
   __proto__: null,
   get() {
     return this;
   },
   configurable: true,
 });
 const kBlockListHandle = Symbol("kBlockListHandle");
-Object.defineProperty(BlockList.prototype, kBlockListHandle, {
+defineBuiltinProperty(BlockList.prototype, kBlockListHandle, {
   __proto__: null,
   get() {
     return this;
@@ -168,7 +170,7 @@ function InternalSocketAddress(handle): void {
 }
 
 const kBlobHandle = Symbol("kBlobHandle");
-Object.defineProperty(Blob.prototype, kBlobHandle, {
+defineBuiltinProperty(Blob.prototype, kBlobHandle, {
   __proto__: null,
   get() {
     return this;