What happens with circular imports?

Neither system rejects a cycle. What differs is what a module sees from a partner that hasn't finished.

ES modules. Linking handles the whole cycle as a unit, so every import binding exists before any code runs. Evaluation is depth-first: starting from the entry module, a module that is already being evaluated is skipped rather than waited for. So the last module in the cycle to be reached runs first, and the entry module runs last.

When a module's body reads a binding that comes from a module that hasn't run yet:

• export function declarations already work, because functions are initialized at link time.
• export const, let, and class are in their Temporal Dead Zone: a ReferenceError, "Cannot access 'a' before initialization".
• export var reads undefined.

Reading the binding later, for example inside a function called after startup, works because the binding is live.

CommonJS. require returns the module.exports object that exists at that moment. If the partner is mid-execution, you get whatever it had assigned so far, usually a partial object. A property added later shows up on the same object, but destructuring (const { x } = require(...)) or replacing module.exports freezes in the early view.

The fix is usually structural: move the shared code into a third module, or read the other side lazily, inside a function.

// a.mjs (entry point)
import { b } from './b.mjs';

export const a = 'a';
export function hello() {
  return 'hello from a';
}
console.log('a sees b =', b);

// b.mjs
import { a, hello } from './a.mjs';

console.log('hello() ->', hello());
try {
  console.log(a);
} catch (error) {
  console.log(error.name, error.message);
}
export const b = 'b';
// → hello() -> hello from a
// → ReferenceError Cannot access 'a' before initialization
// → a sees b = b

• Believing the entry file always runs first. In a cycle, the entry runs last. Which module hits the TDZ depends on which file starts the program or is imported first, so the same code can break from a different entry point (node b.mjs throws in a.mjs).
• Using const f = () => ... where function f() {} would have survived. Both can be exported, but only the declaration is available during the cycle.
• In CommonJS, const { x } = require('./other') in a cycle gives undefined forever. Read other.x when you need it.
• Relying on cycles that "happen to work" today. Adding an import or reordering them changes evaluation order.