From ea461c8037a870df4a817b25e47fe95793ff28fa Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Sun, 4 Oct 2026 09:55:17 -0700 Subject: [PATCH 1/3] fix(module): match Node namespace marker ownership Adapt oven-sh/bun#33894 and #39888 by @robobun. Use the paired WebKit namespace facade API so imports stay unmarked while require(esm) gets an own enumerable marker and live exports. Preserve explicit CJS markers and the Node module.exports namespace entry. Requires the OpenClaw WebKit namespace engine patch; keep this integration in draft until its artifacts are published. --- CHANGELOG.md | 2 + docs/runtime/module-resolution.mdx | 2 + docs/runtime/nodejs-compat.mdx | 2 + src/js/builtins/CommonJS.ts | 36 +--- src/jsc/bindings/JSCommonJSModule.cpp | 24 ++- src/jsc/bindings/NodeVMModule.cpp | 5 - src/jsc/bindings/ZigGlobalObject.cpp | 44 +---- .../import-attributes.test.ts | 10 +- .../bun/namespace-prototype-pollution.test.ts | 9 +- test/js/bun/resolve/esModule.test.ts | 156 +++++++++++++++--- .../require-esm-evaluating-cycle.test.ts | 7 +- .../js/node/module/require-extensions.test.ts | 2 +- 12 files changed, 187 insertions(+), 112 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e6e2a21ad028..b3f785ee5d39 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +- Keep ESM namespaces free of inherited `__esModule` markers and preserve the own marker and live exports for `require(esm)`, fixing Vite/tsx namespace interop. Adapts [oven-sh/bun#33894](https://github.com/oven-sh/bun/pull/33894) and [oven-sh/WebKit#279](https://github.com/oven-sh/WebKit/pull/279). Thanks @robobun! + - Align WebKit and VM source-position assertions with Node's constructor locations and select these regressions for native stack-formatting changes in both fork CI lanes. - Preserve the native-context count in the fast `v8.getHeapStatistics()` adapter and avoid appending a second strict code-generation flag to inherited worker arguments. diff --git a/docs/runtime/module-resolution.mdx b/docs/runtime/module-resolution.mdx index 77760cb4b9ad..8f6b999a1fbc 100644 --- a/docs/runtime/module-resolution.mdx +++ b/docs/runtime/module-resolution.mdx @@ -161,6 +161,8 @@ import Stuff from "./my-commonjs.cjs"; const myStuff = require("./my-commonjs.cjs"); ``` +When `require()` loads an ES module with a default export and no explicit `__esModule` export, it returns a namespace with an own, enumerable `__esModule: true` property. Its exports remain live. Importing the same module returns the original namespace without that added marker. Both namespace objects have a null prototype and reject property assignments. + ### Top level await The only exception to this rule is top-level await. You can't `require()` a file that uses top-level await, since the `require()` function is inherently synchronous. diff --git a/docs/runtime/nodejs-compat.mdx b/docs/runtime/nodejs-compat.mdx index 0274c5b4fcc5..5348a0d42d13 100644 --- a/docs/runtime/nodejs-compat.mdx +++ b/docs/runtime/nodejs-compat.mdx @@ -15,6 +15,8 @@ Stdin and eval scripts report malformed ancestor package metadata only when an i The OpenClaw fork reports missing runtime imports without downloading npm packages. This default covers scripts, workers, and child processes running the fork. You can opt in with `--install=auto|fallback|force` or an explicit bunfig `install.auto` setting. Package-manager commands (`bun install`, `bun add`, `bun x`, and `bunx`) are unchanged. See [Auto-install](/runtime/auto-install). +Module namespaces have a null prototype. `require(esm)` adds an own enumerable `__esModule` marker only for modules with a default export and no explicit marker, without modifying the imported namespace. CommonJS namespaces preserve explicit markers and expose the original exports as `module.exports`. + ## Built-in Node.js modules `Error.prepareStackTrace` supports deletion, descriptor restoration, and accessor replacement. Nested stack formatting and throwing formatters leave later captures usable. diff --git a/src/js/builtins/CommonJS.ts b/src/js/builtins/CommonJS.ts index d4ea37ea1a46..92299d629b59 100644 --- a/src/js/builtins/CommonJS.ts +++ b/src/js/builtins/CommonJS.ts @@ -124,26 +124,11 @@ export function overridableRequire(this: JSCommonJSModule, originalId: string, o const namespace = out; // In a require cycle the namespace is live while the module body is still - // running, so an export named `__esModule` / `module.exports` may be in TDZ. - let esModule, moduleExports; + // running, so an export named `module.exports` may be in TDZ. + let moduleExports; try { - esModule = namespace.__esModule; moduleExports = namespace["module.exports"]; } catch {} - // In Bun, when __esModule is not defined, it's a CustomAccessor on the prototype. - // Various libraries expect __esModule to be set when using ESM from require(). - // We don't want to always inject the __esModule export into every module, - // And creating an Object wrapper causes the actual exports to not be own properties. - // So instead of either of those, we make it so that the __esModule property can be set at runtime. - // It only supports "true" and undefined. Anything non-truthy is treated as undefined. - // https://github.com/oven-sh/bun/issues/14411 - if (esModule === undefined) { - try { - namespace.__esModule = true; - } catch { - // https://github.com/oven-sh/bun/issues/17816 - } - } return (mod.exports = moduleExports ?? namespace); } @@ -217,25 +202,10 @@ export function requireESMFromHijackedExtension(this: JSCommonJSModule, id: stri const namespace = $requireESM(id, this); // See `overridableRequire`: TDZ-safe reads for the require-cycle case. - let esModule, moduleExports; + let moduleExports; try { - esModule = namespace.__esModule; moduleExports = namespace["module.exports"]; } catch {} - // In Bun, when __esModule is not defined, it's a CustomAccessor on the prototype. - // Various libraries expect __esModule to be set when using ESM from require(). - // We don't want to always inject the __esModule export into every module, - // And creating an Object wrapper causes the actual exports to not be own properties. - // So instead of either of those, we make it so that the __esModule property can be set at runtime. - // It only supports "true" and undefined. Anything non-truthy is treated as undefined. - // https://github.com/oven-sh/bun/issues/14411 - if (esModule === undefined) { - try { - namespace.__esModule = true; - } catch { - // https://github.com/oven-sh/bun/issues/17816 - } - } this.exports = moduleExports ?? namespace; } diff --git a/src/jsc/bindings/JSCommonJSModule.cpp b/src/jsc/bindings/JSCommonJSModule.cpp index a043ef3cd3d3..7b8b1e6cc9cb 100644 --- a/src/jsc/bindings/JSCommonJSModule.cpp +++ b/src/jsc/bindings/JSCommonJSModule.cpp @@ -1213,7 +1213,7 @@ void populateESMExports( if (canPerformFastEnumeration(structure)) { exports->structure()->forEachProperty(vm, [&](const PropertyTableEntry& entry) -> bool { auto key = entry.key(); - if (key->isSymbol() || key == esModuleMarker) + if (key->isSymbol()) return true; needsToAssignDefault = needsToAssignDefault && key != vm.propertyNames->defaultKeyword; @@ -1230,7 +1230,7 @@ void populateESMExports( RETURN_IF_EXCEPTION(scope, ); for (auto property : properties) { - if (property.isEmpty() || property.isNull() || property == esModuleMarker || property.isPrivateName() || property.isSymbol()) [[unlikely]] + if (property.isEmpty() || property.isNull() || property.isPrivateName() || property.isSymbol()) [[unlikely]] continue; // ignore constructor @@ -1336,7 +1336,25 @@ void JSCommonJSModule::toSyntheticSource(JSC::JSGlobalObject* globalObject, auto result = this->exportsObject(); RETURN_IF_EXCEPTION(scope, ); - RELEASE_AND_RETURN(scope, populateESMExports(globalObject, result, exportNames, exportValues, this->ignoreESModuleAnnotation)); + populateESMExports(globalObject, result, exportNames, exportValues, this->ignoreESModuleAnnotation); + RETURN_IF_EXCEPTION(scope, ); + + auto& vm = globalObject->vm(); + const auto moduleExports = Identifier::fromString(vm, "module.exports"_s); + exportValues.append(result); + if (exportValues.hasOverflowed()) { + throwOutOfMemoryError(globalObject, scope); + return; + } + // Node's CJS namespace always exposes the original exports through this name. + for (size_t i = 0; i < exportNames.size(); ++i) { + if (exportNames[i] == moduleExports) { + exportValues[i] = exportValues.last(); + exportValues.removeLast(); + return; + } + } + exportNames.append(moduleExports); } void JSCommonJSModule::setExportsObject(JSC::JSValue exportsObject) diff --git a/src/jsc/bindings/NodeVMModule.cpp b/src/jsc/bindings/NodeVMModule.cpp index ef0440c50982..2570d1cda5f7 100644 --- a/src/jsc/bindings/NodeVMModule.cpp +++ b/src/jsc/bindings/NodeVMModule.cpp @@ -348,13 +348,8 @@ JSModuleNamespaceObject* NodeVMModule::namespaceObject(JSC::JSGlobalObject* glob object = amr->getModuleNamespace(globalObject); RETURN_IF_EXCEPTION(scope, {}); if (object) { - // The shared module namespace structure carries an __esModule accessor for - // CJS interop, but a Module Namespace Exotic Object is specified to have a - // null [[Prototype]], which is what vm modules must expose. - object->setPrototypeDirect(vm, jsNull()); namespaceObject(vm, object); } - RETURN_IF_EXCEPTION(scope, {}); return object; } diff --git a/src/jsc/bindings/ZigGlobalObject.cpp b/src/jsc/bindings/ZigGlobalObject.cpp index 2c61e485f1c8..63baae409803 100644 --- a/src/jsc/bindings/ZigGlobalObject.cpp +++ b/src/jsc/bindings/ZigGlobalObject.cpp @@ -883,9 +883,11 @@ JSC_DEFINE_HOST_FUNCTION(functionEsmLoadSync, (JSC::JSGlobalObject * lexicalGlob if (auto* entry = loader->registryEntry(key)) { entryExistedBefore = true; if (isModuleEvaluated(entry->record()) || isModuleEvaluatingSync(entry->record())) { - auto* ns = entry->record()->getModuleNamespace(globalObject, false); + auto* ns = entry->record()->getModuleNamespace(globalObject); RETURN_IF_EXCEPTION(scope, {}); - return JSValue::encode(ns); + auto* required = ns->createNamespaceForRequire(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + return JSValue::encode(required); } // Any other Evaluating record (one with top-level await) must not // reach loadModuleSync: Link() and Evaluate() reject that status. @@ -958,9 +960,11 @@ JSC_DEFINE_HOST_FUNCTION(functionEsmLoadSync, (JSC::JSGlobalObject * lexicalGlob } } - auto* ns = record->getModuleNamespace(globalObject, false); + auto* ns = record->getModuleNamespace(globalObject); RETURN_IF_EXCEPTION(scope, {}); - return JSValue::encode(ns); + auto* required = ns->createNamespaceForRequire(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + return JSValue::encode(required); } #define WEBCORE_GENERATED_CONSTRUCTOR_GETTER(ConstructorName) \ @@ -1990,31 +1994,6 @@ extern "C" napi_env ZigGlobalObject__makeNapiEnvForFFI(Zig::GlobalObject* global } extern "C" JSC::EncodedJSValue CryptoObject__create(JSGlobalObject*); -JSC_DEFINE_CUSTOM_GETTER(moduleNamespacePrototypeGetESModuleMarker, (JSGlobalObject * globalObject, JSC::EncodedJSValue encodedThisValue, PropertyName)) -{ - JSValue thisValue = JSValue::decode(encodedThisValue); - JSModuleNamespaceObject* moduleNamespaceObject = dynamicDowncast(thisValue); - if (!moduleNamespaceObject || moduleNamespaceObject->m_hasESModuleMarker != WTF::TriState::True) { - return JSC::JSValue::encode(jsUndefined()); - } - - return JSC::JSValue::encode(jsBoolean(true)); -} - -JSC_DEFINE_CUSTOM_SETTER(moduleNamespacePrototypeSetESModuleMarker, (JSGlobalObject * globalObject, JSC::EncodedJSValue encodedThisValue, JSC::EncodedJSValue encodedValue, PropertyName)) -{ - auto& vm = JSC::getVM(globalObject); - JSValue thisValue = JSValue::decode(encodedThisValue); - JSModuleNamespaceObject* moduleNamespaceObject = dynamicDowncast(thisValue); - if (!moduleNamespaceObject) { - return false; - } - auto scope = DECLARE_THROW_SCOPE(vm); - JSValue value = JSValue::decode(encodedValue); - WTF::TriState triState = value.toBoolean(globalObject) ? WTF::TriState::True : WTF::TriState::False; - moduleNamespaceObject->m_hasESModuleMarker = triState; - return true; -} namespace { @@ -2347,11 +2326,6 @@ void GlobalObject::finishCreation(VM& vm) createMemoryFootprintStructure( init.vm, static_cast(init.owner))); } }, - { OBJECT_OFFSETOF(GlobalObject, m_moduleNamespaceObjectStructure), [](const LazyProperty::Initializer& init) { - JSObject* moduleNamespacePrototype = JSC::constructEmptyObject(init.vm, init.owner->nullPrototypeObjectStructure()); - moduleNamespacePrototype->putDirectCustomAccessor(init.vm, init.vm.propertyNames->__esModule, CustomGetterSetter::create(init.vm, moduleNamespacePrototypeGetESModuleMarker, moduleNamespacePrototypeSetESModuleMarker), PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::CustomAccessor | 0); - init.set(JSModuleNamespaceObject::createStructure(init.vm, init.owner, moduleNamespacePrototype)); - } }, { OBJECT_OFFSETOF(GlobalObject, m_JSBufferSubclassStructure), [](const LazyProperty::Initializer& init) { auto scope = DECLARE_TOP_EXCEPTION_SCOPE(init.vm); auto* globalObject = static_cast(init.owner); @@ -2684,8 +2658,6 @@ void GlobalObject::finishCreation(VM& vm) dynamicDowncast(init.owner))); }); - // Change prototype from null to object for synthetic modules. - m_vmModuleContextMap.initLater( [](const Initializer& init) { init.set(JSWeakMap::create(init.vm, init.owner->weakMapStructure())); diff --git a/test/js/bun/import-attributes/import-attributes.test.ts b/test/js/bun/import-attributes/import-attributes.test.ts index 2c1888662f74..00eef072d557 100644 --- a/test/js/bun/import-attributes/import-attributes.test.ts +++ b/test/js/bun/import-attributes/import-attributes.test.ts @@ -344,11 +344,11 @@ describe("other loaders do not crash", () => { }); describe("?raw", () => { - for (const [name, fn] of [ - ["bun run", testBunRun], + for (const [name, fn, expected] of [ + ["bun run", testBunRun, {}], // ["bun build", testBunBuild], // TODO: bun.build doesn't support query params at all yet - ["bun run await import", testBunRunAwaitImport], - ["require", testBunRunRequire], + ["bun run await import", testBunRunAwaitImport, {}], + ["require", testBunRunRequire, { __esModule: true }], // ["bun build require", testBunBuildRequire], // TODO: bun.build doesn't support query params at all yet ] as const) { test(name, async () => { @@ -357,7 +357,7 @@ describe("?raw", () => { await using question_raw = tempDir("import-attributes", { [filename]: code, }); - expect(await fn(question_raw, null, filename + "?raw")).toEqual({ default: code }); + expect(await fn(question_raw, null, filename + "?raw")).toEqual({ ...expected, default: code }); }); } }); diff --git a/test/js/bun/namespace-prototype-pollution.test.ts b/test/js/bun/namespace-prototype-pollution.test.ts index 36c25f43652a..bb49b55c983e 100644 --- a/test/js/bun/namespace-prototype-pollution.test.ts +++ b/test/js/bun/namespace-prototype-pollution.test.ts @@ -19,8 +19,9 @@ test("namespace imports should not inherit from Object.prototype", async () => { console.log("PASS: prototype pollution prevented"); } - // Verify __esModule still works - console.log("__esModule settable:", (mod.__esModule = true, mod.__esModule === true)); + console.log("Null prototype:", Object.getPrototypeOf(mod) === null); + console.log("__esModule absent:", !("__esModule" in mod)); + console.log("__esModule immutable:", !Reflect.set(mod, "__esModule", true)); // Original exports should work console.log("Original export:", mod.value); @@ -38,6 +39,8 @@ test("namespace imports should not inherit from Object.prototype", async () => { expect(exitCode).toBe(0); expect(stdout).toContain("PASS: prototype pollution prevented"); - expect(stdout).toContain("__esModule settable: true"); + expect(stdout).toContain("Null prototype: true"); + expect(stdout).toContain("__esModule absent: true"); + expect(stdout).toContain("__esModule immutable: true"); expect(stdout).toContain("Original export: original"); }); diff --git a/test/js/bun/resolve/esModule.test.ts b/test/js/bun/resolve/esModule.test.ts index 1d66d9eded4c..d0b355a37dac 100644 --- a/test/js/bun/resolve/esModule.test.ts +++ b/test/js/bun/resolve/esModule.test.ts @@ -1,31 +1,141 @@ import { expect, test } from "bun:test"; - -// Top-level `await import(self)` is a spec-level deadlock under the new -// pure-C++ module loader (Node prints an "unsettled top-level await" warning -// and exits). A static self-import yields the same namespace object without -// blocking evaluation on itself. +import { bunEnv, bunExe, tempDir } from "harness"; import * as Self from "./esModule.test.ts"; -test("__esModule defaults to undefined", () => { +test("an imported namespace has no inherited or writable __esModule marker", () => { + expect(Object.getPrototypeOf(Self)).toBeNull(); + expect("__esModule" in Self).toBe(false); + expect(Object.hasOwn(Self, "__esModule")).toBe(false); + expect(Object.getOwnPropertyDescriptor(Self, "__esModule")).toBeUndefined(); + expect(Reflect.ownKeys(Self)).toEqual([Symbol.toStringTag]); + expect(Reflect.set(Self, "__esModule", true)).toBe(false); + expect(Reflect.defineProperty(Self, "__esModule", { value: true })).toBe(false); + expect(require("./esModule.test.ts")).toBe(Self); expect(Self.__esModule).toBeUndefined(); }); -test("__esModule is settable", () => { - Self.__esModule = true; - expect(Self.__esModule).toBe(true); - Self.__esModule = false; - expect(Self.__esModule).toBe(undefined); - Self.__esModule = true; - expect(Self.__esModule).toBe(true); - Self.__esModule = undefined; -}); - -test("require of self sets __esModule", () => { - expect(Self.__esModule).toBeUndefined(); - { - const Self = require("./esModule.test.ts"); - expect(Self.__esModule).toBe(true); +for (const order of ["import-first", "require-first"]) { + test.concurrent(`require(esm) marker reflection and live bindings (${order})`, async () => { + using dir = tempDir("namespace-marker", { + "default.mjs": "export default {}; export let value = 1; export function bump() { value++; }", + "none.mjs": "export const value = 1;", + "false.mjs": "export const __esModule = false; export default 1;", + "undefined.mjs": "export const __esModule = undefined; export default 1;", + "true.mjs": "export const __esModule = true; export default 1;", + "sorted.mjs": "export default 1; export const Alpha = 1, _a = 2, zzz = 3;", + "leaf.mjs": "export const value = 'synthetic-ok';", + "alias.mjs": "import * as z from './leaf.mjs'; export * from './leaf.mjs'; export { z, z as default };", + "entry.mjs": ` +import assert from 'node:assert/strict'; +import { createRequire } from 'node:module'; +const require = createRequire(import.meta.url); +function marker(ns, present, value) { + assert.equal(Object.getPrototypeOf(ns), null); + assert.equal(Object.isExtensible(ns), false); + assert.equal('__esModule' in ns, present); + assert.equal(Object.hasOwn(ns, '__esModule'), present); + assert.equal(Object.prototype.hasOwnProperty.call(ns, '__esModule'), present); + assert.deepEqual(Object.getOwnPropertyDescriptor(ns, '__esModule'), present ? { + value, writable: true, enumerable: true, configurable: false, + } : undefined); + assert.equal(Reflect.set(ns, '__esModule', true), false); + assert.equal(Reflect.set(ns, '__esModule', value), false); + assert.equal(Reflect.defineProperty(ns, '__esModule', { value }), present); + for (const descriptor of [{ value: {} }, { writable: false }, { enumerable: false }, { configurable: true }, { get() {} }]) + assert.equal(Reflect.defineProperty(ns, '__esModule', descriptor), false); + assert.equal(Reflect.deleteProperty(ns, '__esModule'), !present); +} +for (const [name, hasDefault, explicit, value] of [ + ['default', true, false, undefined], ['none', false, false, undefined], + ['false', true, true, false], ['undefined', true, true, undefined], ['true', true, true, true], +]) { + let imported, required; + if (${JSON.stringify(order)} === 'import-first') { + imported = await import('./' + name + '.mjs'); + marker(imported, explicit, value); + required = require('./' + name + '.mjs'); + } else { + required = require('./' + name + '.mjs'); + imported = await import('./' + name + '.mjs'); + } + marker(imported, explicit, value); + marker(required, explicit || hasDefault, explicit ? value : hasDefault ? true : undefined); + assert.equal(imported === required, explicit || !hasDefault); + assert.equal(require('./' + name + '.mjs'), required); + delete require.cache[require.resolve('./' + name + '.mjs')]; + const reloaded = require('./' + name + '.mjs'); + assert.equal(reloaded === required, explicit || !hasDefault); + marker(reloaded, explicit || hasDefault, explicit ? value : hasDefault ? true : undefined); + if (name === 'default') { + imported.bump(); + assert.equal(required.value, 2); + assert.equal(({ ...required }).__esModule, true); + assert.equal(Object.assign({}, required).__esModule, true); + assert.equal(JSON.parse(JSON.stringify(required)).__esModule, true); + globalThis.Bun?.gc(true); + assert.equal(required.value, imported.value); } - expect(Self.__esModule).toBe(true); - expect(Object.getOwnPropertyNames(Self)).toBeEmpty(); +} +const sorted = require('./sorted.mjs'); +assert.deepEqual(Reflect.ownKeys(sorted), ['Alpha', '__esModule', '_a', 'default', 'zzz', Symbol.toStringTag]); +assert.deepEqual(Object.keys(sorted), ['Alpha', '__esModule', '_a', 'default', 'zzz']); +const alias = await import('./alias.mjs'); +const interop = alias.default && typeof alias.default === 'object' && '__esModule' in alias.default ? alias.default : alias; +assert.equal(interop.z.value, 'synthetic-ok'); +assert.equal(require('./alias.mjs').__esModule, true); +assert.equal('__esModule' in alias, false); +console.log('ok'); +`, + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "entry.mjs"], + cwd: String(dir), + env: bunEnv, + stdout: "pipe", + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect({ stdout, stderr, exitCode }).toEqual({ stdout: "ok\n", stderr: "", exitCode: 0 }); + }); +} + +test.concurrent("CommonJS-as-ESM namespaces preserve explicit markers and own-key reflection", async () => { + using dir = tempDir("cjs-namespace-marker", { + "plain.cjs": "exports.value = 1;", + "true.cjs": "Object.defineProperty(exports, '__esModule', { value: true }); exports.value = 1;", + "false.cjs": "exports.__esModule = false; exports.value = 1;", + "undefined.cjs": "exports.__esModule = undefined; exports.value = 1;", + "collision.cjs": "exports['module.exports'] = 3; exports.value = 1;", + "entry.mjs": ` +import assert from 'node:assert/strict'; +import { createRequire } from 'node:module'; +const require = createRequire(import.meta.url); +for (const [name, present, value] of [ + ['plain', false], ['true', true, true], ['false', true, false], ['undefined', true, undefined], ['collision', false], +]) { + const ns = await import('./' + name + '.cjs'); + assert.equal(Object.getPrototypeOf(ns), null); + assert.equal(Object.isExtensible(ns), false); + assert.equal('__esModule' in ns, present); + assert.equal(Object.hasOwn(ns, '__esModule'), present); + assert.equal(Object.prototype.hasOwnProperty.call(ns, '__esModule'), present); + assert.deepEqual(Object.getOwnPropertyDescriptor(ns, '__esModule'), present ? { + value, writable: true, enumerable: true, configurable: false, + } : undefined); + assert.deepEqual(Reflect.ownKeys(ns), [...(present ? ['__esModule'] : []), 'default', 'module.exports', 'value', Symbol.toStringTag]); + assert.equal(ns['module.exports'], require('./' + name + '.cjs')); + assert.equal(Reflect.set(ns, '__esModule', true), false); +} +console.log('ok'); +`, + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "entry.mjs"], + cwd: String(dir), + env: bunEnv, + stdout: "pipe", + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect({ stdout, stderr, exitCode }).toEqual({ stdout: "ok\n", stderr: "", exitCode: 0 }); }); diff --git a/test/js/bun/resolve/require-esm-evaluating-cycle.test.ts b/test/js/bun/resolve/require-esm-evaluating-cycle.test.ts index 4002df11c3ce..ec50c1d7f70a 100644 --- a/test/js/bun/resolve/require-esm-evaluating-cycle.test.ts +++ b/test/js/bun/resolve/require-esm-evaluating-cycle.test.ts @@ -44,9 +44,10 @@ test("require(esm) inside a require cycle returns the live namespace, not an emp expect(exitCode).toBe(0); }); -// The CommonJS side reads `__esModule` / `"module.exports"` off that live -// namespace; when the module happens to export a binding by that name that is -// still in TDZ, require() itself must not throw (reading it afterwards does). +// The CommonJS side reads `"module.exports"` off that live namespace. Marker +// selection checks export names without reading the bindings. When either +// binding is still in TDZ, require() itself must not throw +// (reading it afterwards does). test("require(esm) inside a require cycle tolerates a TDZ `__esModule` export", async () => { using dir = tempDir("require-esm-evaluating-cycle-tdz", { "a.mjs": ` diff --git a/test/js/node/module/require-extensions.test.ts b/test/js/node/module/require-extensions.test.ts index 86dfa1d98429..70f3514d979e 100644 --- a/test/js/node/module/require-extensions.test.ts +++ b/test/js/node/module/require-extensions.test.ts @@ -156,7 +156,7 @@ test("wrapping an existing extension but it's secretly sync esm", () => { original(module, filename); })); const mod = require("./extensions-fixture/secretly_esm"); - expect(mod).toEqual({ default: 1 }); + expect({ ...mod }).toEqual({ __esModule: true, default: 1 }); expect(mocked).toBeCalled(); } finally { require.extensions[".cjs"] = original; From fba679a18c7ac197a67c8cd80b91e006653965ea Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Sun, 4 Oct 2026 10:25:56 -0700 Subject: [PATCH 2/3] fix(module): preserve namespace forwarding and cached require markers Create the require facade when require.cache materializes an imported ESM module. Keep native namespaces forwarded through CommonJS intact instead of interpreting their synthetic marker as a Babel wrapper. Preserve the existing Bun contract that cache deletion also invalidates ESM records; test marker ownership separately from that cache policy. --- src/jsc/bindings/JSCommonJSModule.cpp | 3 ++- src/jsc/bindings/ZigGlobalObject.cpp | 6 ++++-- test/js/bun/resolve/esModule-annotation.test.js | 10 +++++----- test/js/bun/resolve/esModule.test.ts | 14 +++++++++++--- 4 files changed, 22 insertions(+), 11 deletions(-) diff --git a/src/jsc/bindings/JSCommonJSModule.cpp b/src/jsc/bindings/JSCommonJSModule.cpp index 7b8b1e6cc9cb..4a11ee7c5b81 100644 --- a/src/jsc/bindings/JSCommonJSModule.cpp +++ b/src/jsc/bindings/JSCommonJSModule.cpp @@ -1188,7 +1188,8 @@ void populateESMExports( if (auto* exports = result.getObject()) { bool hasESModuleMarker = false; - if (!ignoreESModuleAnnotation) { + // A native namespace forwarded by CJS keeps its default binding inside that namespace. + if (!ignoreESModuleAnnotation && !jsDynamicCast(exports)) { PropertySlot slot(exports, PropertySlot::InternalMethodType::VMInquiry, &vm); auto has = exports->getPropertySlot(globalObject, esModuleMarker, slot); RETURN_IF_EXCEPTION(scope, ); diff --git a/src/jsc/bindings/ZigGlobalObject.cpp b/src/jsc/bindings/ZigGlobalObject.cpp index 63baae409803..5e47c42b2d71 100644 --- a/src/jsc/bindings/ZigGlobalObject.cpp +++ b/src/jsc/bindings/ZigGlobalObject.cpp @@ -811,9 +811,11 @@ JSC_DEFINE_HOST_FUNCTION(functionEsmNamespaceForCjs, (JSC::JSGlobalObject * glob RETURN_IF_EXCEPTION(scope, {}); if (!record) return JSValue::encode(jsUndefined()); - auto* ns = record->getModuleNamespace(globalObject, false); + auto* ns = record->getModuleNamespace(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + auto* required = ns->createNamespaceForRequire(globalObject); RETURN_IF_EXCEPTION(scope, {}); - return JSValue::encode(ns); + return JSValue::encode(required); } JSC_DEFINE_HOST_FUNCTION(functionEsmRegistryHasEvaluated, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame)) diff --git a/test/js/bun/resolve/esModule-annotation.test.js b/test/js/bun/resolve/esModule-annotation.test.js index 01c5fb3b40a8..c4bfe3c993b2 100644 --- a/test/js/bun/resolve/esModule-annotation.test.js +++ b/test/js/bun/resolve/esModule-annotation.test.js @@ -21,20 +21,20 @@ describe('without type: "module"', () => { __esModule: true, }); - // The module namespace object will not have the __esModule property. - expect(WithoutTypeModuleExportEsModuleAnnotationNoDefault.__esModule).toBeUndefined(); + expect(Object.hasOwn(WithoutTypeModuleExportEsModuleAnnotationNoDefault, "__esModule")).toBe(true); + expect(WithoutTypeModuleExportEsModuleAnnotationNoDefault.__esModule).toBeTrue(); }); test("exports.default = true; exports.__esModule = true;", () => { expect(WithoutTypeModuleExportEsModuleAnnotation.default).toBeTrue(); - expect(WithoutTypeModuleExportEsModuleAnnotation.__esModule).toBeUndefined(); + expect(WithoutTypeModuleExportEsModuleAnnotation.__esModule).toBeTrue(); }); test("exports.default = true;", () => { expect(WithoutTypeModuleExportEsModuleNoAnnotation.default).toEqual({ default: true, }); - expect(WithoutTypeModuleExportEsModuleAnnotation.__esModule).toBeUndefined(); + expect(WithoutTypeModuleExportEsModuleNoAnnotation.__esModule).toBeUndefined(); }); }); @@ -65,7 +65,7 @@ describe('with type: "module"', () => { expect(WithTypeModuleExportEsModuleNoAnnotation.default).toEqual({ default: true, }); - expect(WithTypeModuleExportEsModuleAnnotation.__esModule).toBeTrue(); + expect(WithTypeModuleExportEsModuleNoAnnotation.__esModule).toBeUndefined(); }); }); diff --git a/test/js/bun/resolve/esModule.test.ts b/test/js/bun/resolve/esModule.test.ts index d0b355a37dac..0f3bc3cbf891 100644 --- a/test/js/bun/resolve/esModule.test.ts +++ b/test/js/bun/resolve/esModule.test.ts @@ -14,7 +14,7 @@ test("an imported namespace has no inherited or writable __esModule marker", () expect(Self.__esModule).toBeUndefined(); }); -for (const order of ["import-first", "require-first"]) { +for (const order of ["import-first", "require-first", "cache-first"]) { test.concurrent(`require(esm) marker reflection and live bindings (${order})`, async () => { using dir = tempDir("namespace-marker", { "default.mjs": "export default {}; export let value = 1; export function bump() { value++; }", @@ -50,9 +50,10 @@ for (const [name, hasDefault, explicit, value] of [ ['false', true, true, false], ['undefined', true, true, undefined], ['true', true, true, true], ]) { let imported, required; - if (${JSON.stringify(order)} === 'import-first') { + if (${JSON.stringify(order)} !== 'require-first') { imported = await import('./' + name + '.mjs'); marker(imported, explicit, value); + if (${JSON.stringify(order)} === 'cache-first') void require.cache[require.resolve('./' + name + '.mjs')]; required = require('./' + name + '.mjs'); } else { required = require('./' + name + '.mjs'); @@ -64,7 +65,8 @@ for (const [name, hasDefault, explicit, value] of [ assert.equal(require('./' + name + '.mjs'), required); delete require.cache[require.resolve('./' + name + '.mjs')]; const reloaded = require('./' + name + '.mjs'); - assert.equal(reloaded === required, explicit || !hasDefault); + // Bun also evicts the ESM registry on cache deletion; only check the added facade's identity. + if (hasDefault && !explicit) assert.notEqual(reloaded, required); marker(reloaded, explicit || hasDefault, explicit ? value : hasDefault ? true : undefined); if (name === 'default') { imported.bump(); @@ -106,6 +108,8 @@ test.concurrent("CommonJS-as-ESM namespaces preserve explicit markers and own-ke "false.cjs": "exports.__esModule = false; exports.value = 1;", "undefined.cjs": "exports.__esModule = undefined; exports.value = 1;", "collision.cjs": "exports['module.exports'] = 3; exports.value = 1;", + "forwarded.mjs": "export default 'kept'; export const value = 1;", + "forwarder.cjs": "module.exports = require('./forwarded.mjs');", "entry.mjs": ` import assert from 'node:assert/strict'; import { createRequire } from 'node:module'; @@ -126,6 +130,10 @@ for (const [name, present, value] of [ assert.equal(ns['module.exports'], require('./' + name + '.cjs')); assert.equal(Reflect.set(ns, '__esModule', true), false); } +const forwarded = await import('./forwarder.cjs'); +assert.equal(forwarded.default, require('./forwarder.cjs')); +assert.equal(forwarded.default.default, 'kept'); +assert.equal(forwarded['module.exports'], forwarded.default); console.log('ok'); `, }); From 72f230bb93bac2fad29f511985ab1f21e11ca793 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Sun, 4 Oct 2026 10:31:07 -0700 Subject: [PATCH 3/3] build: use the pinned JSC namespace cast helper --- src/jsc/bindings/JSCommonJSModule.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/jsc/bindings/JSCommonJSModule.cpp b/src/jsc/bindings/JSCommonJSModule.cpp index 4a11ee7c5b81..a3d891874ed0 100644 --- a/src/jsc/bindings/JSCommonJSModule.cpp +++ b/src/jsc/bindings/JSCommonJSModule.cpp @@ -1189,7 +1189,7 @@ void populateESMExports( if (auto* exports = result.getObject()) { bool hasESModuleMarker = false; // A native namespace forwarded by CJS keeps its default binding inside that namespace. - if (!ignoreESModuleAnnotation && !jsDynamicCast(exports)) { + if (!ignoreESModuleAnnotation && !dynamicDowncast(exports)) { PropertySlot slot(exports, PropertySlot::InternalMethodType::VMInquiry, &vm); auto has = exports->getPropertySlot(globalObject, esModuleMarker, slot); RETURN_IF_EXCEPTION(scope, );