ConcatenatedModule re-export ordering still depends on graph insertion order when sourceOrder and rangeStart tie #22694

const assert = require('node:assert/strict');
const fs = require('node:fs/promises');
const os = require('node:os');
const path = require('node:path');
const webpack = require('webpack');
const ConcatenatedModule = require('webpack/lib/optimize/ConcatenatedModule');

(async () => {
  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'webpack-reexports-'));
  const original = ConcatenatedModule.prototype._createConcatenationList;
  let reverse = false;
  let reordered = 0;
  // Force the two possible connection orders at the point where they are consumed.
  // This models the observed cold/warm-cache difference; it does not test cache IO.
  ConcatenatedModule.prototype._createConcatenationList = function (root, modules, runtime, graph) {
    const get = graph.getOutgoingConnections;
    graph.getOutgoingConnections = function (module) {
      const connections = [...get.call(this, module)];
      if (reverse && connections.length > 1) {
        reordered++;
        connections.reverse();
      }
      return connections;
    };
    try { return original.call(this, root, modules, runtime, graph); }
    finally { graph.getOutgoingConnections = get; }
  };
  async function build(name) {
    const compiler = webpack({
      mode: 'production', context: directory, entry: './index.js', cache: false,
      output: { path: path.join(directory, name), filename: '[contenthash].js', library: { type: 'commonjs2' } },
      optimization: { minimize: false, concatenateModules: true, sideEffects: true }
    });
    await new Promise((resolve, reject) => compiler.run((error, stats) => compiler.close((closeError) => {
      if (error || closeError) reject(error || closeError);
      else if (!stats || stats.hasErrors()) reject(new Error(stats?.toString()));
      else resolve();
    })));
    const files = await fs.readdir(path.join(directory, name));
    assert.equal(files.length, 1);
    return { name: files[0], source: await fs.readFile(path.join(directory, name, files[0]), 'utf8') };
  }
  try {
    for (const [name, source] of Object.entries({
      'package.json': '{"sideEffects":false}',
      'index.js': 'export { a, b } from "./barrel.js";',
      'barrel.js': 'export { a } from "./a.js"; export { b } from "./b.js";',
      'a.js': 'export const a = () => globalThis.x;',
      'b.js': 'export const b = () => globalThis.y;'
    })) await fs.writeFile(path.join(directory, name), source);
    const first = await build('first');
    reverse = true;
    const second = await build('second');
    assert.ok(reordered > 0);
    console.log({ webpack: webpack.version, first: first.name, second: second.name });
    assert.deepEqual(second, first);
  } finally {
    ConcatenatedModule.prototype._createConcatenationList = original;
    await fs.rm(directory, { recursive: true, force: true });
  }
})().catch(error => { console.error(error); process.exitCode = 1; });