diff --git a/src/js/internal/assert/assertion_error.ts b/src/js/internal/assert/assertion_error.ts
index 1890b9320888..89a6fd82288d 100644
--- a/src/js/internal/assert/assertion_error.ts
+++ b/src/js/internal/assert/assertion_error.ts
@@ -3,6 +3,7 @@
 const { inspect } = require("internal/util/inspect");
 const colors = require("internal/util/colors");
 const { validateObject } = require("internal/validators");
+const { isErrorStackTraceLimitWritable } = require("internal/shared");
 const { myersDiff, printMyersDiff, printSimpleMyersDiff } = require("internal/assert/myers_diff") as typeof Internal;
 
 const ErrorCaptureStackTrace = Error.captureStackTrace;
@@ -274,9 +275,9 @@ class AssertionError extends Error {
     } = options;
     let { actual, expected } = options;
 
-    // NOTE: stack trace is always writable.
+    const stackTraceLimitWritable = isErrorStackTraceLimitWritable();
     const limit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 0;
+    if (stackTraceLimitWritable) Error.stackTraceLimit = 0;
 
     if (message != null) {
       if (operator === "deepStrictEqual" || operator === "strictEqual") {
@@ -370,7 +371,7 @@ class AssertionError extends Error {
       }
     }
 
-    Error.stackTraceLimit = limit;
+    if (stackTraceLimitWritable) Error.stackTraceLimit = limit;
 
     this.generatedMessage = !message;
     ObjectDefineProperty(this, "name", {
diff --git a/src/js/internal/freeze_intrinsics.ts b/src/js/internal/freeze_intrinsics.ts
new file mode 100644
index 000000000000..912048ed7bbd
--- /dev/null
+++ b/src/js/internal/freeze_intrinsics.ts
@@ -0,0 +1,347 @@
+// Adapted from SES/Caja - Copyright (C) 2011 Google Inc.
+// Copyright (C) 2018 Agoric
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Port of Node.js lib/internal/freeze_intrinsics.js. Runs before user code.
+
+const _String = String;
+const _TypeError = TypeError;
+const ObjectDefineProperty = Object.defineProperty;
+const ObjectFreeze = Object.freeze;
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const ObjectGetOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const ObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
+const ObjectGetPrototypeOf = Object.getPrototypeOf;
+const ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
+const ReflectOwnKeys = Reflect.ownKeys;
+const SymbolIterator = Symbol.iterator;
+const SymbolMatchAll = Symbol.matchAll;
+const TypedArray = ObjectGetPrototypeOf(Uint8Array);
+
+process.emitWarning("Frozen intristics is an experimental feature and might change at any time", "ExperimentalWarning");
+
+{
+  const intrinsicPrototypes: unknown[] = [
+    // 20 Fundamental Objects
+    Object.prototype, // 20.1
+    Function.prototype, // 20.2
+    Boolean.prototype, // 20.3
+    Symbol.prototype, // 20.4
+
+    Error.prototype, // 20.5
+    AggregateError.prototype,
+    EvalError.prototype,
+    RangeError.prototype,
+    ReferenceError.prototype,
+    SuppressedError.prototype,
+    SyntaxError.prototype,
+    TypeError.prototype,
+    URIError.prototype,
+
+    // 21 Numbers and Dates
+    Number.prototype, // 21.1
+    BigInt.prototype, // 21.2
+    Date.prototype, // 21.4
+
+    // 22 Text Processing
+    String.prototype, // 22.1
+    ObjectGetPrototypeOf(String.prototype[SymbolIterator]()), // 22.1.5 StringIteratorPrototype
+    RegExp.prototype, // 22.2
+    ObjectGetPrototypeOf(new RegExp("e")[SymbolMatchAll]("")), // 22.2.7 RegExpStringIteratorPrototype
+
+    // 23 Indexed Collections
+    Array.prototype, // 23.1
+    ObjectGetPrototypeOf(Array.prototype[SymbolIterator]()), // 23.1.5 ArrayIteratorPrototype
+    TypedArray.prototype, // 23.2
+    Int8Array.prototype,
+    Uint8Array.prototype,
+    Uint8ClampedArray.prototype,
+    Int16Array.prototype,
+    Uint16Array.prototype,
+    Int32Array.prototype,
+    Uint32Array.prototype,
+    Float16Array.prototype,
+    Float32Array.prototype,
+    Float64Array.prototype,
+    BigInt64Array.prototype,
+    BigUint64Array.prototype,
+
+    // 24 Keyed Collections
+    Map.prototype, // 24.1
+    ObjectGetPrototypeOf(new Map()[SymbolIterator]()), // 24.1.5 MapIteratorPrototype
+    Set.prototype, // 24.2
+    ObjectGetPrototypeOf(new Set()[SymbolIterator]()), // 24.2.5 SetIteratorPrototype
+    WeakMap.prototype, // 24.3
+    WeakSet.prototype, // 24.4
+
+    // 25 Structured Data
+    ArrayBuffer.prototype, // 25.1
+    DataView.prototype, // 25.3
+
+    // 26 Managing Memory
+    WeakRef.prototype, // 26.1
+    FinalizationRegistry.prototype, // 26.2
+
+    // 27 Control Abstraction Objects
+    ObjectGetPrototypeOf(ObjectGetPrototypeOf(Array.prototype[SymbolIterator]())), // 27.1.2 IteratorPrototype
+    ObjectGetPrototypeOf(ObjectGetPrototypeOf(ObjectGetPrototypeOf((async function* () {})()))), // 27.1.3 AsyncIteratorPrototype
+    Promise.prototype, // 27.2
+    DisposableStack.prototype,
+    AsyncDisposableStack.prototype,
+
+    // 28 Reflection
+    ShadowRealm.prototype,
+
+    // Other APIs / Web Compatibility
+    (console as { Console?: { prototype: object } }).Console?.prototype,
+  ];
+
+  const intrinsics: unknown[] = [
+    // 10.2.4.1 ThrowTypeError
+    ObjectGetOwnPropertyDescriptor(Function.prototype, "caller")?.get,
+
+    // 19 The Global Object
+    // 19.2 Function Properties of the Global Object
+    eval,
+    isFinite,
+    isNaN,
+    parseFloat,
+    parseInt,
+    decodeURI,
+    decodeURIComponent,
+    encodeURI,
+    encodeURIComponent,
+
+    // 20 Fundamental Objects
+    Object,
+    Function,
+    Boolean,
+    Symbol,
+    Error,
+    AggregateError,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SuppressedError,
+    SyntaxError,
+    TypeError,
+    URIError,
+
+    // 21 Numbers and Dates
+    Number,
+    BigInt,
+    Math,
+    Date,
+
+    // 22 Text Processing
+    String,
+    ObjectGetPrototypeOf(String.prototype[SymbolIterator]()),
+    RegExp,
+    ObjectGetPrototypeOf(new RegExp("e")[SymbolMatchAll]("")),
+
+    // 23 Indexed Collections
+    Array,
+    ObjectGetPrototypeOf(Array.prototype[SymbolIterator]()),
+    TypedArray,
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float16Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array,
+
+    // 24 Keyed Collections
+    Map,
+    ObjectGetPrototypeOf(new Map()[SymbolIterator]()),
+    Set,
+    ObjectGetPrototypeOf(new Set()[SymbolIterator]()),
+    WeakMap,
+    WeakSet,
+
+    // 25 Structured Data
+    ArrayBuffer,
+    DataView,
+    Atomics,
+    JSON,
+
+    // 26 Managing Memory
+    WeakRef,
+    FinalizationRegistry,
+
+    // 27 Control Abstraction Objects
+    Iterator,
+    ObjectGetPrototypeOf(ObjectGetPrototypeOf(Array.prototype[SymbolIterator]())), // IteratorPrototype
+    ObjectGetPrototypeOf(ObjectGetPrototypeOf(ObjectGetPrototypeOf((async function* () {})()))), // AsyncIteratorPrototype
+    Promise,
+    ObjectGetPrototypeOf(function* () {}), // GeneratorFunction
+    ObjectGetPrototypeOf(async function* () {}), // AsyncGeneratorFunction
+    ObjectGetPrototypeOf(async function () {}), // AsyncFunction
+    DisposableStack,
+    AsyncDisposableStack,
+
+    // 28 Reflection
+    Reflect,
+    Proxy,
+    ShadowRealm,
+
+    // B.2.1
+    escape,
+    unescape,
+
+    // Other APIs / Web Compatibility
+    clearImmediate,
+    clearInterval,
+    clearTimeout,
+    setImmediate,
+    setInterval,
+    setTimeout,
+    console,
+  ];
+
+  if (typeof SharedArrayBuffer !== "undefined") {
+    intrinsicPrototypes.push(SharedArrayBuffer.prototype);
+    intrinsics.push(SharedArrayBuffer);
+  }
+  if (typeof WebAssembly !== "undefined") {
+    intrinsicPrototypes.push(
+      WebAssembly.Module.prototype,
+      WebAssembly.Instance.prototype,
+      WebAssembly.Table.prototype,
+      WebAssembly.Memory.prototype,
+      WebAssembly.CompileError.prototype,
+      WebAssembly.LinkError.prototype,
+      WebAssembly.RuntimeError.prototype,
+    );
+    intrinsics.push(WebAssembly);
+  }
+  if (typeof Intl !== "undefined") {
+    intrinsicPrototypes.push(
+      Intl.Collator.prototype,
+      Intl.DateTimeFormat.prototype,
+      Intl.ListFormat.prototype,
+      Intl.NumberFormat.prototype,
+      Intl.PluralRules.prototype,
+      Intl.RelativeTimeFormat.prototype,
+    );
+    intrinsics.push(Intl);
+  }
+
+  for (let i = 0; i < intrinsicPrototypes.length; i++) enableDerivedOverrides(intrinsicPrototypes[i]);
+
+  const WeakSetAdd = WeakSet.prototype.add;
+  const WeakSetHas = WeakSet.prototype.has;
+  const frozenSet = new WeakSet<object>();
+  // In Node.js `console._stdout`/`_stderr` are getters; in Bun they are data
+  // properties, so seed them as visited to keep stream prototypes unfrozen.
+  const { _stdout, _stderr } = console as { _stdout?: object; _stderr?: object };
+  if (_stdout) WeakSetAdd.$call(frozenSet, _stdout);
+  if (_stderr) WeakSetAdd.$call(frozenSet, _stderr);
+  for (let i = 0; i < intrinsics.length; i++) deepFreeze(intrinsics[i]);
+
+  // 19.1 Value Properties of the Global Object
+  ObjectDefineProperty(globalThis, "globalThis", {
+    __proto__: null,
+    configurable: false,
+    writable: false,
+    value: globalThis,
+  } as PropertyDescriptor);
+
+  function deepFreeze(root: unknown): void {
+    const queue: object[] = [];
+
+    function enqueue(val: unknown): void {
+      const t = typeof val;
+      if ((t !== "object" && t !== "function") || val === null) return;
+      if (WeakSetHas.$call(frozenSet, val as object)) return;
+      WeakSetAdd.$call(frozenSet, val as object);
+      $putByValDirect(queue, queue.length, val as object);
+    }
+
+    enqueue(root);
+    for (let i = 0; i < queue.length; i++) {
+      const obj = queue[i];
+      ObjectFreeze(obj);
+      enqueue(ObjectGetPrototypeOf(obj));
+      const descs = ObjectGetOwnPropertyDescriptors(obj);
+      const keys = ReflectOwnKeys(descs);
+      for (let k = 0; k < keys.length; k++) {
+        const desc = descs[keys[k] as string];
+        if (ObjectPrototypeHasOwnProperty.$call(desc, "value")) {
+          enqueue(desc.value);
+        } else {
+          enqueue(desc.get);
+          enqueue(desc.set);
+        }
+      }
+    }
+  }
+
+  // Convert data properties to accessors so `derived.prop = x` still defines
+  // an own property after the inherited slot is frozen (ES5 override mistake).
+  function enableDerivedOverride(obj: object, prop: PropertyKey, desc: PropertyDescriptor): void {
+    if (!ObjectPrototypeHasOwnProperty.$call(desc, "value") || !desc.configurable) return;
+    const value = desc.value;
+
+    function getter(this: unknown) {
+      return value;
+    }
+    (getter as { value?: unknown }).value = value;
+
+    function setter(this: unknown, newValue: unknown) {
+      if (obj === this) {
+        throw new _TypeError(`Cannot assign to read only property '${_String(prop)}' of object '${obj}'`);
+      }
+      if (ObjectPrototypeHasOwnProperty.$call(this, prop)) {
+        (this as Record<PropertyKey, unknown>)[prop as string] = newValue;
+      } else {
+        ObjectDefineProperty(this as object, prop, {
+          __proto__: null,
+          value: newValue,
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        } as PropertyDescriptor);
+      }
+    }
+
+    ObjectDefineProperty(obj, prop, {
+      __proto__: null,
+      get: getter,
+      set: setter,
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+    } as PropertyDescriptor);
+  }
+
+  function enableDerivedOverrides(obj: unknown): void {
+    if (!obj) return;
+    const descs = ObjectGetOwnPropertyDescriptors(obj);
+    if (!descs) return;
+    const names = ObjectGetOwnPropertyNames(obj);
+    for (let i = 0; i < names.length; i++) enableDerivedOverride(obj as object, names[i], descs[names[i]]);
+    const syms = ObjectGetOwnPropertySymbols(obj);
+    for (let i = 0; i < syms.length; i++)
+      enableDerivedOverride(obj as object, syms[i], descs[syms[i] as unknown as string]);
+  }
+}
+
+export default {};
diff --git a/src/js/internal/process/pre_execution.ts b/src/js/internal/process/pre_execution.ts
index 682006ae4c0d..ead9767491a5 100644
--- a/src/js/internal/process/pre_execution.ts
+++ b/src/js/internal/process/pre_execution.ts
@@ -126,10 +126,11 @@ 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 stlWritable = require("internal/shared").isErrorStackTraceLimitWritable();
       const limit = Error.stackTraceLimit;
-      Error.stackTraceLimit = limit + 3;
+      if (stlWritable) Error.stackTraceLimit = limit + 3;
       const stack = new Error().stack!.split("\n");
-      Error.stackTraceLimit = limit;
+      if (stlWritable) Error.stackTraceLimit = limit;
       // stack[0] = "Error", [1] = printEnvTrace, [2] = the proxy trap.
       let corrected = false;
       for (let i = 3; i < stack.length; i++) {
diff --git a/src/js/internal/repl/node-errors.js b/src/js/internal/repl/node-errors.js
index 84c2c29eecc6..72874f892048 100644
--- a/src/js/internal/repl/node-errors.js
+++ b/src/js/internal/repl/node-errors.js
@@ -74,11 +74,7 @@ for (const fn of [
   });
 }
 
-function isErrorStackTraceLimitWritable() {
-  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-  if (desc === undefined) return Object.isExtensible(Error);
-  return Object.prototype.hasOwnProperty.$call(desc, "writable") ? desc.writable : desc.set !== undefined;
-}
+const { isErrorStackTraceLimitWritable } = require("internal/shared");
 
 export default {
   isErrorStackTraceLimitWritable,
diff --git a/src/js/internal/shared.ts b/src/js/internal/shared.ts
index 605fc2974f23..30569cbd0562 100644
--- a/src/js/internal/shared.ts
+++ b/src/js/internal/shared.ts
@@ -147,6 +147,12 @@ function once(callback, { preserveReturnValue = false } = kEmptyObject) {
 
 const kEmptyObject = ObjectFreeze(Object.create(null));
 
+function isErrorStackTraceLimitWritable(): boolean {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === undefined) return Object.isExtensible(Error);
+  return Object.prototype.hasOwnProperty.$call(desc, "writable") ? desc.writable! : desc.set !== undefined;
+}
+
 // Marks an addEventListener() options object so that dispatch still invokes the
 // listener after an unrelated listener called event.stopImmediatePropagation().
 // `$kResistStopPropagation` is a private symbol the native EventTarget reads, so
@@ -341,6 +347,7 @@ export default {
   once,
   getLazy,
   resistStopPropagation,
+  isErrorStackTraceLimitWritable,
 
   hasObserver,
   startPerf,
diff --git a/src/js/internal/trace_events.ts b/src/js/internal/trace_events.ts
index 0f26ade9e373..2a18fa36493f 100644
--- a/src/js/internal/trace_events.ts
+++ b/src/js/internal/trace_events.ts
@@ -696,6 +696,7 @@ function wrapFsAsyncMethod(original, names: string[]) {
 // semantics mirror Node: count starts at 1, countReset emits 0, time/timeLog/
 // timeEnd emit 'b'/'n'/'e' under `time::<label>` only while the label is live.
 function installConsoleInstrumentation() {
+  if (Object.isFrozen(console)) return;
   const counts = new Map<string, number>();
   const timeLabels = new Set<string>();
   const originalCount = console.count;
diff --git a/src/js/internal/util/inspect.js b/src/js/internal/util/inspect.js
index 09d55ecafcbe..e5ee08557229 100644
--- a/src/js/internal/util/inspect.js
+++ b/src/js/internal/util/inspect.js
@@ -290,10 +290,11 @@ const codes = {}; // exported from errors.js
     return msg;
   });
   codes[sym] = function NodeError(...args) {
+    const stlWritable = require("internal/shared").isErrorStackTraceLimitWritable();
     const limit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 0;
+    if (stlWritable) Error.stackTraceLimit = 0;
     const error = new TypeError();
-    Error.stackTraceLimit = limit; // Reset the limit and setting the name property.
+    if (stlWritable) Error.stackTraceLimit = limit; // Reset the limit and setting the name property.
 
     const msg = messages.get(sym);
     assert(typeof msg === "function");
@@ -315,9 +316,9 @@ const codes = {}; // exported from errors.js
     // addCodeToName + captureLargerStackTrace
     let err = error;
     const userStackTraceLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = Infinity;
+    if (stlWritable) Error.stackTraceLimit = Infinity;
     ErrorCaptureStackTrace(err);
-    Error.stackTraceLimit = userStackTraceLimit; // Reset the limit
+    if (stlWritable) Error.stackTraceLimit = userStackTraceLimit; // Reset the limit
     err.name = `${TypeError.name} [${sym}]`; // Add the error code to the name to include it in the stack trace.
     void err.stack; // Access the stack to generate the error message including the error code from the name.
     delete err.name; // Reset the name to the actual name.
diff --git a/src/js/node/events.ts b/src/js/node/events.ts
index cca5fa632b62..465f41c51da5 100644
--- a/src/js/node/events.ts
+++ b/src/js/node/events.ts
@@ -62,7 +62,7 @@ var defaultMaxListeners = 10;
 
 // EventEmitter must be a standard function because some old code will do weird tricks like `EventEmitter.$apply(this)`.
 function EventEmitter(opts) {
-  if (this._events === undefined || this._events === this.__proto__._events) {
+  if (this._events === undefined || this._events === $getPrototypeOf(this)._events) {
     this._events = Object.create(null);
     this._eventsCount = 0;
     this[kShapeMode] = false;
diff --git a/src/js/node/util.ts b/src/js/node/util.ts
index b00362b6e81f..061e751e3da5 100644
--- a/src/js/node/util.ts
+++ b/src/js/node/util.ts
@@ -460,18 +460,18 @@ function getCallSites(frameCount = 10, options) {
   const target = {};
   const savedPrepareStackTrace = Error.prepareStackTrace;
   const savedStackTraceLimit = Error.stackTraceLimit;
+  // --frozen-intrinsics (or user code) may have made Error non-writable;
+  // best-effort so the capture still runs and both are always restored.
   try {
-    Error.prepareStackTrace = prepareCallSites;
-    // User code may have made stackTraceLimit non-writable; best-effort so the
-    // capture still runs and prepareStackTrace is always restored.
     try {
+      Error.prepareStackTrace = prepareCallSites;
       Error.stackTraceLimit = frameCount;
     } catch {}
     Error.captureStackTrace(target, getCallSites);
-    return target.stack;
+    return $isJSArray(target.stack) ? target.stack : [];
   } finally {
-    Error.prepareStackTrace = savedPrepareStackTrace;
     try {
+      Error.prepareStackTrace = savedPrepareStackTrace;
       Error.stackTraceLimit = savedStackTraceLimit;
     } catch {}
   }
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index 191c40190c98..787d30a21581 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -2274,6 +2274,18 @@ impl VirtualMachine {
         }
     }
 
+    /// Runs `internal/freeze_intrinsics` for `--frozen-intrinsics`. Called
+    /// after `load_preloads` so `--require`/`--import` polyfills land first.
+    fn maybe_freeze_intrinsics(&self) {
+        unsafe extern "C" {
+            static Bun__Node__FrozenIntrinsics: core::sync::atomic::AtomicBool;
+        }
+        // SAFETY: `#[no_mangle]` static defined in `bun_runtime::cli::Arguments`.
+        if unsafe { Bun__Node__FrozenIntrinsics.load(core::sync::atomic::Ordering::Relaxed) } {
+            crate::cpp::Bun__freezeIntrinsics(self.global());
+        }
+    }
+
     /// `reloadEntryPoint(entry_path)` — set `main`, generate the synthetic
     /// `bun:main` entry, run preloads, and kick off module evaluation.
     pub fn reload_entry_point(
@@ -2349,6 +2361,8 @@ impl VirtualMachine {
                     }
                 }
 
+                self.maybe_freeze_intrinsics();
+
                 // Check if Module.runMain was patched.
                 if self.has_patched_run_main {
                     bun_core::hint::cold();
@@ -2373,6 +2387,8 @@ impl VirtualMachine {
                 }
             }
 
+            self.maybe_freeze_intrinsics();
+
             // Note: reshaped for borrowck — capture raw ptr before &self call.
             let global = self.global;
             let global_ref = self.global();
@@ -2397,6 +2413,7 @@ impl VirtualMachine {
             JSValue::from_cell(promise).ensure_still_alive();
             Ok(promise)
         } else {
+            self.maybe_freeze_intrinsics();
             let global = self.global;
             let main_str = bun_core::String::from_bytes(self.main());
             let promise =
@@ -4529,6 +4546,8 @@ impl VirtualMachine {
             }
         }
 
+        self.maybe_freeze_intrinsics();
+
         // Note: reshaped for borrowck.
         let global = self.global;
         let main_str = bun_core::String::from_bytes(self.main());
diff --git a/src/jsc/bindings/ErrorCode.ts b/src/jsc/bindings/ErrorCode.ts
index b36ab04d45ce..83d844c4b0b3 100644
--- a/src/jsc/bindings/ErrorCode.ts
+++ b/src/jsc/bindings/ErrorCode.ts
@@ -174,6 +174,7 @@ const errors: ErrorCodeMapping = [
   ["ERR_PARSE_ARGS_INVALID_OPTION_VALUE", TypeError],
   ["ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", TypeError],
   ["ERR_PARSE_ARGS_UNKNOWN_OPTION", TypeError],
+  ["ERR_PROTO_ACCESS", Error],
   ["ERR_POSTGRES_AUTHENTICATION_FAILED_PBKDF2", Error, "PostgresError"],
   ["ERR_POSTGRES_CONNECTION_CLOSED", Error, "PostgresError"],
   ["ERR_POSTGRES_CONNECTION_TIMEOUT", Error, "PostgresError"],
diff --git a/src/jsc/bindings/ExposeNodeModuleGlobals.cpp b/src/jsc/bindings/ExposeNodeModuleGlobals.cpp
index 44905bd58102..70d6d0e361f2 100644
--- a/src/jsc/bindings/ExposeNodeModuleGlobals.cpp
+++ b/src/jsc/bindings/ExposeNodeModuleGlobals.cpp
@@ -108,6 +108,19 @@ extern "C" [[ZIG_EXPORT(nothrow)]] void Bun__preExecutionBootstrap(Zig::GlobalOb
     }
 }
 
+// Evaluate `internal/freeze_intrinsics`. Called after load_preloads so
+// --require/--import polyfills land before the freeze (Node.js ordering).
+extern "C" [[ZIG_EXPORT(nothrow)]] void Bun__freezeIntrinsics(Zig::GlobalObject* globalObject)
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);
+    globalObject->internalModuleRegistry()->requireId(globalObject, vm, Bun::InternalModuleRegistry::InternalFreezeIntrinsics);
+    if (auto* exception = scope.exception()) [[unlikely]] {
+        CLEAR_IF_EXCEPTION(scope);
+        Bun__reportError(globalObject, JSC::JSValue::encode(exception));
+    }
+}
+
 // Set up require(), module, __filename, __dirname on globalThis for the REPL.
 // Creates a CommonJS module object rooted at the given directory so require() resolves correctly.
 extern "C" [[ZIG_EXPORT(check_slow)]] void Bun__REPL__setupGlobalRequire(
diff --git a/src/jsc/bindings/NodeVM.cpp b/src/jsc/bindings/NodeVM.cpp
index 4af8172edc49..60f17afe2f7a 100644
--- a/src/jsc/bindings/NodeVM.cpp
+++ b/src/jsc/bindings/NodeVM.cpp
@@ -1079,6 +1079,8 @@ void NodeVMGlobalObject::finishCreation(JSC::VM& vm)
     JSC::DeletePropertySlot slot;
     JSC::JSObject::deleteProperty(this, this, vm.propertyNames->Loader, slot);
 
+    Bun::applyNodeDisableProto(this);
+
     vm.ensureTerminationException();
 
     // Share the async context data with the parent global object.
diff --git a/src/jsc/bindings/ZigGlobalObject.cpp b/src/jsc/bindings/ZigGlobalObject.cpp
index a45cf0016dfe..073adb7718d9 100644
--- a/src/jsc/bindings/ZigGlobalObject.cpp
+++ b/src/jsc/bindings/ZigGlobalObject.cpp
@@ -238,6 +238,34 @@ BUN_DECLARE_HOST_FUNCTION(BUN__HTTP2_assertSettings);
 
 JSC_DECLARE_HOST_FUNCTION(jsFunctionMakeAbortError);
 
+extern "C" bool Bun__Node__DisallowCodeGenerationFromStrings;
+extern "C" uint8_t Bun__Node__DisableProto;
+
+JSC_DEFINE_HOST_FUNCTION(functionProtoAccessDisabled, (JSC::JSGlobalObject * globalObject, JSC::CallFrame*))
+{
+    auto scope = DECLARE_THROW_SCOPE(JSC::getVM(globalObject));
+    return Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_PROTO_ACCESS,
+        "Accessing Object.prototype.__proto__ has been disallowed with --disable-proto=throw"_s);
+}
+
+namespace Bun {
+void applyNodeDisableProto(JSC::JSGlobalObject* globalObject)
+{
+    if (!Bun__Node__DisableProto) [[likely]]
+        return;
+    auto& vm = JSC::getVM(globalObject);
+    auto* proto = globalObject->objectPrototype();
+    JSC::DeletePropertySlot slot;
+    JSC::JSObject::deleteProperty(proto, globalObject, vm.propertyNames->underscoreProto, slot);
+    if (Bun__Node__DisableProto == 2) {
+        auto* thrower = JSC::JSFunction::create(vm, globalObject, 0, String(), functionProtoAccessDisabled, JSC::ImplementationVisibility::Public);
+        auto* accessor = JSC::GetterSetter::create(vm, globalObject, thrower, thrower);
+        proto->putDirectAccessor(globalObject, vm.propertyNames->underscoreProto, accessor,
+            static_cast<unsigned>(JSC::PropertyAttribute::Accessor) | static_cast<unsigned>(JSC::PropertyAttribute::DontEnum));
+    }
+}
+}
+
 using JSGlobalObject = JSC::JSGlobalObject;
 using Exception = JSC::Exception;
 using JSValue = JSC::JSValue;
@@ -2832,6 +2860,11 @@ void GlobalObject::finishCreation(VM& vm)
 
     addBuiltinGlobals(vm);
 
+    if (Bun__Node__DisallowCodeGenerationFromStrings) [[unlikely]] {
+        setEvalEnabled(false, "Code generation from strings disallowed for this context"_s);
+    }
+    Bun::applyNodeDisableProto(this);
+
     ASSERT(classInfo());
 }
 
diff --git a/src/jsc/bindings/ZigGlobalObject.h b/src/jsc/bindings/ZigGlobalObject.h
index ca759a74da9e..11ed39699a9e 100644
--- a/src/jsc/bindings/ZigGlobalObject.h
+++ b/src/jsc/bindings/ZigGlobalObject.h
@@ -845,6 +845,8 @@ ALWAYS_INLINE void* vm(JSC::JSGlobalObject* lexicalGlobalObject)
     return WebCore::clientData(lexicalGlobalObject->vm())->bunVM;
 }
 
+void applyNodeDisableProto(JSC::JSGlobalObject*);
+
 }
 
 #ifndef RENAMED_JSDOM_GLOBAL_OBJECT
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 9cd13cc7e6d6..7fd6f9925316 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -307,6 +307,12 @@ pub(crate) const RUNTIME_PARAMS_: &[ParamType] = &[
     parse_param!("--trace-exit"),
     parse_param!("--expose-internals"),
     parse_param!("--stack-trace-limit <STR>"),
+    // Node.js hardening flags. Applied in ZigGlobalObject::finishCreation.
+    parse_param!("--disallow-code-generation-from-strings"),
+    parse_param!("--disable-proto <STR>"),
+    parse_param!("--frozen-intrinsics"),
+    parse_param!("--secure-heap <STR>"),
+    parse_param!("--secure-heap-min <STR>"),
 ];
 
 pub(crate) const AUTO_OR_RUN_PARAMS: &[ParamType] = &[
@@ -686,6 +692,23 @@ pub(crate) static Bun__Node__ProcessNoDeprecation: core::sync::atomic::AtomicBoo
 #[unsafe(no_mangle)]
 pub(crate) static Bun__Node__ProcessThrowDeprecation: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
+#[unsafe(no_mangle)]
+pub(crate) static Bun__Node__DisallowCodeGenerationFromStrings: core::sync::atomic::AtomicBool =
+    core::sync::atomic::AtomicBool::new(false);
+#[unsafe(no_mangle)]
+pub static Bun__Node__FrozenIntrinsics: core::sync::atomic::AtomicBool =
+    core::sync::atomic::AtomicBool::new(false);
+
+#[repr(u8)]
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub(crate) enum DisableProto {
+    Off,
+    Delete,
+    Throw,
+}
+#[unsafe(no_mangle)]
+pub(crate) static Bun__Node__DisableProto: core::sync::atomic::AtomicU8 =
+    core::sync::atomic::AtomicU8::new(DisableProto::Off as u8);
 
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -1289,6 +1312,32 @@ pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::TransformO
         if args.flag(b"--zero-fill-buffers") {
             Bun__Node__ZeroFillBuffers.store(true, core::sync::atomic::Ordering::Relaxed);
         }
+        if args.flag(b"--disallow-code-generation-from-strings") {
+            Bun__Node__DisallowCodeGenerationFromStrings
+                .store(true, core::sync::atomic::Ordering::Relaxed);
+        }
+        if args.flag(b"--frozen-intrinsics") {
+            Bun__Node__FrozenIntrinsics.store(true, core::sync::atomic::Ordering::Relaxed);
+        }
+        if let Some(mode) = args.option(b"--disable-proto") {
+            let mode = match mode {
+                b"delete" => DisableProto::Delete,
+                b"throw" => DisableProto::Throw,
+                _ => {
+                    bun_core::pretty_errorln!(
+                        "<r><red>error<r>: invalid mode passed to --disable-proto: \"{}\". Must be one of \"delete\", \"throw\"",
+                        BStr::new(mode),
+                    );
+                    Global::exit(12);
+                }
+            };
+            Bun__Node__DisableProto.store(mode as u8, core::sync::atomic::Ordering::Relaxed);
+        }
+        if args.option(b"--secure-heap").is_some() || args.option(b"--secure-heap-min").is_some() {
+            bun_core::warn!(
+                "--secure-heap is not supported: Bun links against BoringSSL, which does not implement a secure heap"
+            );
+        }
         let use_system_ca = args.flag(b"--use-system-ca");
         let use_openssl_ca = args.flag(b"--use-openssl-ca");
         let use_bundled_ca = args.flag(b"--use-bundled-ca");
diff --git a/test/js/node/process/node-hardening-flags.test.ts b/test/js/node/process/node-hardening-flags.test.ts
new file mode 100644
index 000000000000..97f77c9a8594
--- /dev/null
+++ b/test/js/node/process/node-hardening-flags.test.ts
@@ -0,0 +1,322 @@
+import { describe, expect, test as test_ } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+
+const test = test_.concurrent;
+// --frozen-intrinsics and worker spawns are ~3s each under debug+ASAN.
+const SLOW = 30_000;
+
+async function run(flags: string[], code: string) {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), ...flags, "-e", code],
+    env: bunEnv,
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  return { stdout, stderr, exitCode };
+}
+
+describe("--disallow-code-generation-from-strings", () => {
+  test("eval() throws EvalError", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disallow-code-generation-from-strings"],
+      `try { eval("1"); console.log("eval WORKS"); } catch (e) { console.log(e.name + ": " + e.message); }`,
+    );
+    expect(stdout.trim()).toBe("EvalError: Code generation from strings disallowed for this context");
+    expect(exitCode).toBe(0);
+  });
+
+  test("new Function() throws EvalError", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disallow-code-generation-from-strings"],
+      `try { new Function("return 1")(); console.log("Function WORKS"); } catch (e) { console.log(e.name + ": " + e.message); }`,
+    );
+    expect(stdout.trim()).toBe("EvalError: Code generation from strings disallowed for this context");
+    expect(exitCode).toBe(0);
+  });
+
+  test(
+    "applies to worker threads",
+    async () => {
+      const { stdout, exitCode } = await run(
+        ["--disallow-code-generation-from-strings"],
+        `const { Worker } = require("worker_threads");
+         const w = new Worker('try { eval("1"); console.log("worker: eval WORKS"); } catch (e) { console.log("worker: " + e.name); }', { eval: true });
+         w.on("exit", () => {});`,
+      );
+      expect(stdout.trim()).toBe("worker: EvalError");
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test("WebAssembly is not affected", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disallow-code-generation-from-strings"],
+      `WebAssembly.compile(new Uint8Array([0,97,115,109,1,0,0,0])).then(() => console.log("wasm ok"), e => console.log("wasm blocked"));`,
+    );
+    expect(stdout.trim()).toBe("wasm ok");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe("--disable-proto", () => {
+  test("=delete removes Object.prototype.__proto__", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=delete"],
+      `console.log(JSON.stringify({
+         hasOwn: Object.prototype.hasOwnProperty("__proto__"),
+         read: typeof ({}).__proto__,
+       }))`,
+    );
+    expect(JSON.parse(stdout)).toEqual({ hasOwn: false, read: "undefined" });
+    expect(exitCode).toBe(0);
+  });
+
+  test("=delete makes __proto__ assignment a plain own property", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=delete"],
+      `const o = {}; o.__proto__ = { x: 1 }; console.log(JSON.stringify({ own: Object.hasOwn(o, "__proto__"), x: o.x }));`,
+    );
+    expect(JSON.parse(stdout)).toEqual({ own: true, x: undefined });
+    expect(exitCode).toBe(0);
+  });
+
+  test("=throw makes __proto__ getter throw ERR_PROTO_ACCESS", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=throw"],
+      `try { ({}).__proto__; console.log("readable"); } catch (e) { console.log(e.code + ": " + e.message); }`,
+    );
+    expect(stdout.trim()).toBe(
+      "ERR_PROTO_ACCESS: Accessing Object.prototype.__proto__ has been disallowed with --disable-proto=throw",
+    );
+    expect(exitCode).toBe(0);
+  });
+
+  test("=throw makes __proto__ setter throw ERR_PROTO_ACCESS", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=throw"],
+      `try { ({}).__proto__ = null; console.log("set ok"); } catch (e) { console.log(e.code); }`,
+    );
+    expect(stdout.trim()).toBe("ERR_PROTO_ACCESS");
+    expect(exitCode).toBe(0);
+  });
+
+  test("=throw still has own-property accessor on Object.prototype", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=throw"],
+      `const d = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");
+       console.log(JSON.stringify({
+         hasOwn: Object.prototype.hasOwnProperty("__proto__"),
+         enumerable: d.enumerable,
+         configurable: d.configurable,
+         hasGet: typeof d.get === "function",
+         hasSet: typeof d.set === "function",
+       }));`,
+    );
+    expect(JSON.parse(stdout)).toEqual({
+      hasOwn: true,
+      enumerable: false,
+      configurable: true,
+      hasGet: true,
+      hasSet: true,
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  test(
+    "=throw applies to worker threads",
+    async () => {
+      const { stdout, exitCode } = await run(
+        ["--disable-proto=throw"],
+        `const { Worker } = require("worker_threads");
+         const w = new Worker('try { ({}).__proto__; console.log("worker: readable"); } catch (e) { console.log("worker: " + e.code); }', { eval: true });
+         w.on("exit", () => {});`,
+      );
+      expect(stdout.trim()).toBe("worker: ERR_PROTO_ACCESS");
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test("invalid mode exits 12", async () => {
+    const { stderr, exitCode } = await run(["--disable-proto=bogus"], `console.log("ran")`);
+    expect(stderr).toContain("invalid mode passed to --disable-proto");
+    expect(exitCode).toBe(12);
+  });
+
+  test("applies to node:vm contexts (throw)", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=throw"],
+      `const vm = require("vm"); const ctx = vm.createContext();
+       try { vm.runInContext("({}).__proto__", ctx); console.log("readable"); }
+       catch (e) { console.log(e.code); }`,
+    );
+    expect(stdout.trim()).toBe("ERR_PROTO_ACCESS");
+    expect(exitCode).toBe(0);
+  });
+
+  test("applies to node:vm contexts (delete)", async () => {
+    const { stdout, exitCode } = await run(
+      ["--disable-proto=delete"],
+      `const vm = require("vm"); const ctx = vm.createContext();
+       console.log(vm.runInContext("Object.prototype.hasOwnProperty('__proto__')", ctx));`,
+    );
+    expect(stdout.trim()).toBe("false");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe("--frozen-intrinsics", () => {
+  test(
+    "freezes ECMA-262 intrinsics but not globalThis, and emits ExperimentalWarning",
+    async () => {
+      const { stdout, stderr, exitCode } = await run(
+        ["--frozen-intrinsics"],
+        `console.log(JSON.stringify({
+           arrProto: Object.isFrozen(Array.prototype),
+           objProto: Object.isFrozen(Object.prototype),
+           promise: Object.isFrozen(Promise),
+           math: Object.isFrozen(Math),
+           f16: Object.isFrozen(Float16Array.prototype),
+           suppressedError: Object.isFrozen(SuppressedError.prototype),
+           disposableStack: Object.isFrozen(DisposableStack.prototype),
+           asyncDisposableStack: Object.isFrozen(AsyncDisposableStack.prototype),
+           iterator: Object.isFrozen(Iterator),
+           console: Object.isFrozen(console),
+           globalThis: Object.isFrozen(globalThis),
+           slotConfigurable: Object.getOwnPropertyDescriptor(globalThis, "globalThis").configurable,
+           streams: Object.isFrozen(require("stream").Duplex.prototype),
+         }))`,
+      );
+      expect(JSON.parse(stdout)).toEqual({
+        arrProto: true,
+        objProto: true,
+        promise: true,
+        math: true,
+        f16: true,
+        suppressedError: true,
+        disposableStack: true,
+        asyncDisposableStack: true,
+        iterator: true,
+        console: true,
+        globalThis: false,
+        slotConfigurable: false,
+        streams: false,
+      });
+      expect(stderr).toContain("ExperimentalWarning");
+      expect(stderr).toContain("experimental feature");
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test(
+    "intrinsic prototype assignment throws but derived-object assignment still works",
+    async () => {
+      const { stdout, exitCode } = await run(
+        ["--frozen-intrinsics"],
+        `"use strict";
+         let proto; try { Array.prototype.push = 1; proto = "mutated"; } catch (e) { proto = e.name; }
+         const o = {}; o.toString = () => "overridden";
+         console.log(JSON.stringify({ proto, derived: o.toString() }));`,
+      );
+      expect(JSON.parse(stdout)).toEqual({ proto: "TypeError", derived: "overridden" });
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test(
+    "builtins that write to frozen Error/console are guarded",
+    async () => {
+      const { stdout, exitCode } = await run(
+        ["--frozen-intrinsics"],
+        `let assertCode;
+         try { require("assert").strictEqual(1, 2); assertCode = "no throw"; } catch (e) { assertCode = e.code; }
+         const sites = require("util").getCallSites();
+         let traceThrew = false;
+         try { require("trace_events").createTracing({categories:["node.console"]}).enable(); } catch { traceThrew = true; }
+         console.log(JSON.stringify({ assert: assertCode, callSitesIsArray: Array.isArray(sites), traceThrew }));`,
+      );
+      expect(JSON.parse(stdout)).toEqual({ assert: "ERR_ASSERTION", callSitesIsArray: true, traceThrew: false });
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test(
+    "--require preloads run before the freeze",
+    async () => {
+      using dir = tempDir("frozen-intrinsics-preload", {
+        "poly.cjs": `Array.prototype.myPolyfill = 1;`,
+      });
+      await using proc = Bun.spawn({
+        cmd: [
+          bunExe(),
+          "--frozen-intrinsics",
+          "--require",
+          "./poly.cjs",
+          "-e",
+          `console.log(JSON.stringify({ frozen: Object.isFrozen(Array.prototype), poly: Array.prototype.myPolyfill }))`,
+        ],
+        env: bunEnv,
+        cwd: String(dir),
+        stderr: "pipe",
+      });
+      const [stdout, , exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      expect(JSON.parse(stdout)).toEqual({ frozen: true, poly: 1 });
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+
+  test(
+    "freeze runs even when a --require preload patches Module.runMain",
+    async () => {
+      using dir = tempDir("frozen-intrinsics-runmain", {
+        "loader.cjs": `const M = require("module"); const orig = M.runMain; M.runMain = function (...a) { return orig.apply(this, a); };`,
+        "entry.js": `console.log(JSON.stringify({ frozen: Object.isFrozen(Array.prototype) }))`,
+      });
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "--frozen-intrinsics", "--require", "./loader.cjs", "entry.js"],
+        env: bunEnv,
+        cwd: String(dir),
+        stderr: "pipe",
+      });
+      const [stdout, , exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      expect(JSON.parse(stdout)).toEqual({ frozen: true });
+      expect(exitCode).toBe(0);
+    },
+    SLOW,
+  );
+});
+
+describe("--secure-heap", () => {
+  test("is recognised and warns that BoringSSL lacks a secure heap", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      ["--secure-heap=4096"],
+      `console.log(typeof require("crypto").secureHeapUsed())`,
+    );
+    expect(stderr).toContain("--secure-heap is not supported");
+    expect(stderr).toContain("BoringSSL");
+    expect(stdout.trim()).toBe("undefined");
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe("without flags", () => {
+  test("eval works", async () => {
+    const { stdout } = await run([], `console.log(eval("1+1"))`);
+    expect(stdout.trim()).toBe("2");
+  });
+
+  test("__proto__ is readable", async () => {
+    const { stdout } = await run([], `console.log(({}).__proto__ === Object.prototype)`);
+    expect(stdout.trim()).toBe("true");
+  });
+
+  test("Array.prototype is not frozen", async () => {
+    const { stdout } = await run([], `console.log(Object.isFrozen(Array.prototype))`);
+    expect(stdout.trim()).toBe("false");
+  });
+});