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..a3d891874ed0 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 && !dynamicDowncast(exports)) { PropertySlot slot(exports, PropertySlot::InternalMethodType::VMInquiry, &vm); auto has = exports->getPropertySlot(globalObject, esModuleMarker, slot); RETURN_IF_EXCEPTION(scope, ); @@ -1213,7 +1214,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 +1231,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 +1337,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..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, {}); - return JSValue::encode(ns); + auto* required = ns->createNamespaceForRequire(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + return JSValue::encode(required); } JSC_DEFINE_HOST_FUNCTION(functionEsmRegistryHasEvaluated, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame)) @@ -883,9 +885,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, {}); + auto* required = ns->createNamespaceForRequire(globalObject); RETURN_IF_EXCEPTION(scope, {}); - return JSValue::encode(ns); + 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 +962,11 @@ JSC_DEFINE_HOST_FUNCTION(functionEsmLoadSync, (JSC::JSGlobalObject * lexicalGlob } } - 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); } #define WEBCORE_GENERATED_CONSTRUCTOR_GETTER(ConstructorName) \ @@ -1990,31 +1996,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 +2328,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 +2660,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-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 1d66d9eded4c..0f3bc3cbf891 100644 --- a/test/js/bun/resolve/esModule.test.ts +++ b/test/js/bun/resolve/esModule.test.ts @@ -1,31 +1,149 @@ 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", "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++; }", + "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)} !== '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'); + 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'); + // 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(); + 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;", + "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'; +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); +} +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'); +`, + }); + 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;