test: load specs as native ES modules

[MarshallOfSound]

Description of Change

Before: specs were CommonJS at runtime: a require hook transpiled each spec/**/*.ts with the TypeScript compiler API as it was loaded.

After: spec/package.json declares "type": "module" and the runner and every spec load through Node's own ESM loader and built-in type stripping, with no transpile step. spec/fixtures/package.json keeps fixtures in a CommonJS scope so they behave as before.

The change is in two commits to make it reviewable. The first is purely mechanical, produced by the script below and an oxfmt run: relative imports gain their real file extension, __dirname/__filename become import.meta.dirname/.filename, and files that still call require() from module code get a createRequire prelude (code inside functions that are stringified and run in another process is left alone). The second commit is the hand-written part: spec/index.js becomes an ES module that import()s its dependencies after the app is ready and calls mocha.loadFilesAsync(); test bodies that are stringified and sent elsewhere now arrive as written rather than as CommonJS transpiler output, so the remote-control and utility-process fixtures define the plain names those bodies use instead of the old electron_1-style shims; the two specs that exercise lib/ sources require() them; and tsconfig.spec.json allows .ts extension imports, with a spec/tsconfig.json so editors pick it up.

Codemod used for the first commit

// Mechanical part of moving spec/ to native ES modules:
//  1. relative import specifiers get their real file extension
//  2. __dirname / __filename become import.meta.dirname / import.meta.filename
//  3. files that still call require() from module code get a createRequire()
//     prelude
// Code inside functions that are stringified and evaluated in another process
// (remotely(), itremote(), `${fn}` and friends) is left untouched by 2 and 3.
// Run from the repo root:
//   node spec-esm-codemod.js spec/*.ts spec/lib/*.ts && yarn oxfmt 'spec/*.ts' 'spec/lib/*.ts'
const fs = require('node:fs');
const path = require('node:path');
const ts = require(path.resolve('node_modules/typescript'));

// Helpers whose function arguments are serialised and evaluated elsewhere.
const STRINGIFIERS = new Set(['remotely', 'itremote', 'itUtility', 'runInUtility', 'remoteEval', 'callWithBindings', 'makeBindingWindow']);

let specifiers = 0;
let metas = 0;
let preludes = 0;

const addExtension = (file, spec) => {
  if (/\.(m?[jt]s|cjs|json|node)$/.test(spec)) return spec;
  const base = path.resolve(path.dirname(file), spec);
  for (const ext of ['.ts', '.js', '.mjs']) {
    if (fs.existsSync(base + ext)) return spec + ext;
  }
  for (const ext of ['.ts', '.js']) {
    if (fs.existsSync(path.join(base, 'index' + ext))) return `${spec}/index${ext}`;
  }
  throw new Error(`${file}: cannot resolve ${spec}`);
};

const calleeNames = (expr, names = []) => {
  if (ts.isIdentifier(expr)) names.push(expr.text);
  else if (ts.isPropertyAccessExpression(expr)) {
    names.push(expr.name.text);
    calleeNames(expr.expression, names);
  } else if (ts.isCallExpression(expr) || ts.isElementAccessExpression(expr)) calleeNames(expr.expression, names);
  return names;
};

const unwrap = (node) => (ts.isParenthesizedExpression(node.parent) ? unwrap(node.parent) : node);

const functionName = (fn) =>
  fn.name?.text ?? (ts.isVariableDeclaration(fn.parent) && ts.isIdentifier(fn.parent.name) ? fn.parent.name.text : null);

const isFunctionLike = (node) => ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node);

// Is this expression in a position whose value ends up serialised: interpolated
// into a template, .toString()ed, or passed to one of the stringifier helpers?
const inStringifiedPosition = (node, stringifiers) => {
  node = unwrap(node);
  const parent = node.parent;
  if (ts.isTemplateSpan(parent)) return true;
  if (ts.isPropertyAccessExpression(parent) && parent.name.text === 'toString') return true;
  if (ts.isCallExpression(parent) && parent.arguments.includes(node)) {
    return calleeNames(parent.expression).some((name) => stringifiers.has(name));
  }
  return false;
};

// Returns { edits: [[start, end, text]], needsRequire } for the module-scope code of a file.
const analyse = (file, text) => {
  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
  const stringifiers = new Set(STRINGIFIERS);
  const stringifiedNames = new Set();

  // Names in this file that are bound to functions.
  const declaredFunctions = new Set();
  const collect = (node) => {
    if (ts.isFunctionDeclaration(node) && node.name) declaredFunctions.add(node.name.text);
    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isFunctionLike(node.initializer)) {
      declaredFunctions.add(node.name.text);
    }
    ts.forEachChild(node, collect);
  };
  collect(sf);
  const isFunctionTyped = (param) =>
    param.type && (ts.isFunctionTypeNode(param.type) || (ts.isTypeReferenceNode(param.type) && param.type.typeName.getText(sf) === 'Function'));

  // Local functions that are referenced by name in a stringified position, and
  // local helpers that stringify one of their own function-typed parameters
  // (calls to those helpers then count as stringifiers too). Iterate to a
  // fixed point.
  for (let changed = true; changed; ) {
    changed = false;
    const scan = (node, fnStack) => {
      if (isFunctionLike(node)) fnStack = [...fnStack, node];
      if (ts.isIdentifier(node) && inStringifiedPosition(node, stringifiers)) {
        if (declaredFunctions.has(node.text) && !stringifiedNames.has(node.text)) {
          stringifiedNames.add(node.text);
          changed = true;
        }
        for (const fn of fnStack) {
          if (fn.parameters.some((p) => ts.isIdentifier(p.name) && p.name.text === node.text && isFunctionTyped(p))) {
            const name = functionName(fn);
            if (name && !stringifiers.has(name)) {
              stringifiers.add(name);
              changed = true;
            }
          }
        }
      }
      ts.forEachChild(node, (child) => scan(child, fnStack));
    };
    scan(sf, []);
  }

  const isStringifiedFunction = (fn) =>
    inStringifiedPosition(fn, stringifiers) || stringifiedNames.has(functionName(fn));

  const isReference = (id) => {
    const p = id.parent;
    if ((ts.isPropertyAccessExpression(p) && p.name === id) || (ts.isPropertyAssignment(p) && p.name === id)) return false;
    if ((ts.isVariableDeclaration(p) || ts.isParameter(p) || ts.isBindingElement(p)) && p.name === id) return false;
    return true;
  };

  const edits = [];
  let needsRequire = false;
  const visit = (node, stringified) => {
    if (isFunctionLike(node) && isStringifiedFunction(node)) stringified = true;
    if (!stringified && ts.isIdentifier(node) && isReference(node)) {
      if (node.text === 'require') needsRequire = true;
      if (node.text === '__dirname') edits.push([node.getStart(sf), node.end, 'import.meta.dirname']);
      if (node.text === '__filename') edits.push([node.getStart(sf), node.end, 'import.meta.filename']);
    }
    ts.forEachChild(node, (child) => visit(child, stringified));
  };
  visit(sf, false);
  return { edits, needsRequire };
};

for (const file of process.argv.slice(2)) {
  const src = fs.readFileSync(file, 'utf8');
  let out = src.replace(/((?:from|import)\s*\(?\s*)(['"])(\.\.?\/[^'"]+)\2/g, (m, pre, q, spec) => {
    const resolved = addExtension(file, spec);
    if (resolved !== spec) specifiers++;
    return `${pre}${q}${resolved}${q}`;
  });

  const { edits, needsRequire } = analyse(file, out);
  for (const [start, end, replacement] of edits.sort((a, b) => b[0] - a[0])) {
    out = out.slice(0, start) + replacement + out.slice(end);
    metas++;
  }

  if (needsRequire && !out.includes('createRequire')) {
    const lines = out.split('\n');
    let last = -1;
    for (let i = 0; i < lines.length; i++) {
      if (/^import .*';$/.test(lines[i]) || /^} from '.*';$/.test(lines[i])) last = i;
      else if (last !== -1 && lines[i].trim() !== '' && !/^import |^  |^}/.test(lines[i])) break;
    }
    const prelude = ["import { createRequire } from 'node:module';", '', 'const require = createRequire(import.meta.url);'];
    if (last === -1) lines.unshift(...prelude, '');
    else lines.splice(last + 1, 0, ...prelude);
    out = lines.join('\n');
    preludes++;
  }

  if (out !== src) fs.writeFileSync(file, out);
}

console.log(`rewrote ${specifiers} specifiers and ${metas} __dirname/__filename uses, added ${preludes} createRequire preludes`);

Checklist

• I have filled out the PR description
• I have reviewed and verified the changes
• tests are changed or added

Release Notes

Notes: none

---

Generated by Claude Code

[ckerr]

LGTM. Reviewed manually and with Astra xhigh.

Note: manual review skimmed the mechanical commit, did active review on the second commit.

[release-clerk]

No Release Notes

[trop]

@MarshallOfSound has manually backported this PR to "45-x-y", please check out #54193

[trop]

@MarshallOfSound has manually backported this PR to "44-x-y", please check out #54194

[trop]

@MarshallOfSound has manually backported this PR to "43-x-y", please check out #54195

[trop]

@MarshallOfSound has manually backported this PR to "42-x-y", please check out #54196