How to reorder modules in a bundle

[nartallax]

I want to write a plugin that solves circular dependency problem.
For that, I need to reorder modules within the bundle (so the circular dependency is resolved properly).
The question is, how do I properly do this without reimplementing @parcel/bundler-default or @parcel/packager-js? Because default packager/bundler are quite logic-heavy and I don't want to lose all this logic, as well as redo it from scratch.

I already have code that figures out proper order of modules, and now I don't know how to tell Parcel that I need that order of modules.
I tried to create a packager plugin, but looks like packager assumes that graph is already built and cannot be modified.
I tried to create a bundler plugin, but I cannot figure out how to tell the mutable graph that I want to remove dependency of asset A on asset B, or to create such dependency.

[mischnic]

What exactly is the problem you're trying to solve? If you use ESM imports correct, then circular dependencies should work correctly

[nartallax]

Well, they don't.

Smallest example would be something like

a.js:

import {b} from "./b"

export const a = () => {
	return Math.random() > 0.5 ? b() : 0
}

b.js:

import {a} from "./a"

export const b = () => {
	return Math.random() > 0.5 ? a() : 1
}

console.log(a())

main.js:

import {a} from "./a"
import {b} from "./b"

console.log(a(), b())

Depending on order of the imports in main.js, the bundle will or will not fail in runtime because of not defined symbol.
This happens because Parcel's bundler/packager does not take into account if values from import are used at definition time synchronously or not; it's obvious for us that b.js uses a.js synchronously, so a.js should always be defined before b.js.
And that's what my plugin tries to do - it tries to reorder dependencies in a way that don't result in runtime error.

[mischnic]

According to the Javascript spec, that should throw an error.

I don't see how you could achieve easily.

[nartallax]

Can you show me that part of spec please? I could not find it right away. Maybe I'm just not good with specs.

Having a non-breaking order is totally achievable, I did it in the past in my bundler. The only problem is porting this logic to Parcel.

My bundler does it by wrapping each module definition in Proxy, making evaluation lazy; this way no module is evaluated until it's required (but all modules are evaluated before entrypoint is executed), so circular dependencies resolve themselves.

Hovewer, it's a performance hit, and it makes scope-hoisting optimizations mostly useless; so right now my strategy is to analyse source code (like, build AST and traverse it) at compile time to figure out which dependencies can be "broken" safely and just lay out modules in proper order. This won't work as well, because there's always a way to obscure code to a point that any source code analyser won't understand what's going on; but it will catch easy cases quite well; and that's all I need.

[mischnic]

Somewhere in here: https://tc39.es/ecma262/multipage/ecmascript-language-scripts-and-modules.html#figure-module-graph-cycle
But the general problem of course is that the specification doesn't have to explicitly mention the behaviour of the overall system (if that follows from implementing the specification).
(And my personal rule so far has been that Node.js conforms to the spec, if I can't find some detail in the spec myself.)

I believe you that it's achievable, but I don't see a point trying to achieve something that won't work across everywhere (runtimes and bundlers) anyway.

I suppose you could wrap modules in proxies in a transformer plugin, and then maybe insert a runtime that requires them all before the entrypoint is run.