@knighted/module 1.0.0-beta.1 → 1.0.0-beta.3

package/README.md

@@ -9,6 +9,12 @@ Node.js utility for transforming a JavaScript or TypeScript file from an ES modu
 - ES module ➡️ CommonJS
 - CommonJS ➡️ ES module
 
+Highlights
+
+- Defaults to safe CommonJS output: strict live bindings, import.meta shims, and specifier preservation.
+- Opt into stricter/looser behaviors: live binding enforcement, import.meta.main gating, and top-level await strategies.
+- Can optionally rewrite relative specifiers and write transformed output to disk.
+
 > [!IMPORTANT]  
 > All parsing logic is applied under the assumption the code is in [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) which [modules run under by default](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules#other_differences_between_modules_and_classic_scripts).
 
@@ -18,9 +24,15 @@ By default `@knighted/module` transforms the one-to-one [differences between ES
 
 - Node >= 20.11.0
 
+## Install
+
+```bash
+npm install @knighted/module
+```
+
 ## Example
 
-Given an ES module
+Given an ES module:
 
 **file.js**
 
@@ -40,7 +52,7 @@ const detectCalledFromCli = async path => {
 detectCalledFromCli(argv[1])
 ```
 
-You can transform it to the equivalent CommonJS module
+Transform it to CommonJS:
 
 ```js
 import { transform } from '@knighted/module'
@@ -51,7 +63,7 @@ await transform('./file.js', {
 })
 ```
 
-Which produces
+Which produces:
 
 **file.cjs**
 
@@ -99,6 +111,7 @@ type ModuleOptions = {
     | ((value: string) => string | null | undefined)
   dirFilename?: 'inject' | 'preserve' | 'error'
   importMeta?: 'preserve' | 'shim' | 'error'
+  importMetaMain?: 'shim' | 'warn' | 'error'
   requireSource?: 'builtin' | 'create-require'
   cjsDefault?: 'module-exports' | 'auto' | 'none'
   topLevelAwait?: 'error' | 'wrap' | 'preserve'
@@ -107,7 +120,24 @@ type ModuleOptions = {
 }
 ```
 
+Behavior notes (defaults in parentheses)
+
+- `target` (`commonjs`): output module system.
+- `transformSyntax` (true): enable/disable the ESM↔CJS lowering pass.
+- `liveBindings` (`strict`): getter-based live bindings, or snapshot (`loose`/`off`).
+- `dirFilename` (`inject`): inject `__dirname`/`__filename`, preserve existing, or throw.
+- `importMeta` (`shim`): rewrite `import.meta.*` to CommonJS equivalents.
+- `importMetaMain` (`shim`): gate `import.meta.main` with shimming/warning/error when Node support is too old.
+- `topLevelAwait` (`error`): throw, wrap, or preserve when TLA appears in CommonJS output.
+- `rewriteSpecifier` (off): rewrite relative specifiers to a chosen extension or via a callback.
+- `requireSource` (`builtin`): whether `require` comes from Node or `createRequire`.
+- `cjsDefault` (`auto`): bundler-style default interop vs direct `module.exports`.
+- `out`/`inPlace`: write the transformed code to a file; otherwise the function returns the transformed string only.
+
+See [docs/esm-to-cjs.md](docs/esm-to-cjs.md) for deeper notes on live bindings, interop helpers, top-level await behavior, and `import.meta.main` handling. For CommonJS to ESM lowering details, read [docs/cjs-to-esm.md](docs/cjs-to-esm.md).
+
 ## Roadmap
 
 - Remove `@knighted/specifier` and avoid double parsing.
-- Flesh out live-binding and top-level await handling.
+- Emit source maps and clearer diagnostics for transform choices.
+- Broaden fixtures covering live-binding and top-level await edge cases across Node versions.

package/dist/cjs/format.cjs

@@ -15,6 +15,313 @@ var _identifiers = require("#utils/identifiers.js");
 var _identifier2 = require("#helpers/identifier.js");
 var _walk = require("#walk");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const isValidIdent = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+const exportAssignment = (name, expr, live) => {
+  const prop = isValidIdent(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+  if (live === 'strict') {
+    const key = JSON.stringify(name);
+    return `Object.defineProperty(exports, ${key}, { enumerable: true, get: () => ${expr} });`;
+  }
+  return `exports${prop} = ${expr};`;
+};
+const defaultInteropName = '__interopDefault';
+const interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const isRequireCallee = (callee, shadowed) => {
+  if (callee.type === 'Identifier' && callee.name === 'require' && !shadowed.has('require')) {
+    return true;
+  }
+  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'module' && !shadowed.has('module') && callee.property.type === 'Identifier' && callee.property.name === 'require') {
+    return true;
+  }
+  return false;
+};
+const isStaticRequire = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed) && node.arguments.length === 1 && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string';
+const isRequireCall = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed);
+const lowerCjsRequireToImports = (program, code, shadowed) => {
+  const transforms = [];
+  const imports = [];
+  let nsIndex = 0;
+  let needsCreateRequire = false;
+  for (const stmt of program.body) {
+    if (stmt.type === 'VariableDeclaration') {
+      const decls = stmt.declarations;
+      const allStatic = decls.length > 0 && decls.every(decl => decl.init && isStaticRequire(decl.init, shadowed));
+      if (allStatic) {
+        for (const decl of decls) {
+          const init = decl.init;
+          const source = code.slice(init.arguments[0].start, init.arguments[0].end);
+          if (decl.id.type === 'Identifier') {
+            imports.push(`import * as ${decl.id.name} from ${source};\n`);
+          } else if (decl.id.type === 'ObjectPattern') {
+            const ns = `__cjsImport${nsIndex++}`;
+            const pattern = code.slice(decl.id.start, decl.id.end);
+            imports.push(`import * as ${ns} from ${source};\n`);
+            imports.push(`const ${pattern} = ${ns};\n`);
+          } else {
+            needsCreateRequire = true;
+          }
+        }
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      for (const decl of decls) {
+        const init = decl.init;
+        if (init && isRequireCall(init, shadowed)) {
+          needsCreateRequire = true;
+        }
+      }
+    }
+    if (stmt.type === 'ExpressionStatement') {
+      const expr = stmt.expression;
+      if (expr && isStaticRequire(expr, shadowed)) {
+        const source = code.slice(expr.arguments[0].start, expr.arguments[0].end);
+        imports.push(`import ${source};\n`);
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      if (expr && isRequireCall(expr, shadowed)) {
+        needsCreateRequire = true;
+      }
+    }
+  }
+  return {
+    transforms,
+    imports,
+    needsCreateRequire
+  };
+};
+const isRequireMainMember = (node, shadowed) => node && node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'require' && !shadowed.has('require') && node.property.type === 'Identifier' && node.property.name === 'main';
+const hasTopLevelAwait = program => {
+  let found = false;
+  const walkNode = (node, inFunction) => {
+    if (found) return;
+    switch (node.type) {
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        inFunction = true;
+        break;
+    }
+    if (!inFunction && node.type === 'AwaitExpression') {
+      found = true;
+      return;
+    }
+    const keys = Object.keys(node);
+    for (const key of keys) {
+      const value = node[key];
+      if (!value) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object') {
+            walkNode(item, inFunction);
+            if (found) return;
+          }
+        }
+      } else if (value && typeof value === 'object') {
+        walkNode(value, inFunction);
+        if (found) return;
+      }
+    }
+  };
+  walkNode(program, false);
+  return found;
+};
+const lowerEsmToCjs = (program, code, opts, containsTopLevelAwait) => {
+  const live = opts.liveBindings ?? 'strict';
+  const importTransforms = [];
+  const exportTransforms = [];
+  let needsInterop = false;
+  let importIndex = 0;
+  for (const node of program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      const specifiers = node.specifiers ?? [];
+      const defaultSpec = specifiers.find(s => s.type === 'ImportDefaultSpecifier');
+      const namespaceSpec = specifiers.find(s => s.type === 'ImportNamespaceSpecifier');
+      const namedSpecs = specifiers.filter(s => s.type === 'ImportSpecifier');
+
+      // Side-effect import
+      if (!specifiers.length) {
+        importTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `require(${srcLiteral});\n`,
+          needsInterop: false
+        });
+        continue;
+      }
+      const modIdent = `__mod${importIndex++}`;
+      const lines = [];
+      lines.push(`const ${modIdent} = require(${srcLiteral});`);
+      if (namespaceSpec) {
+        lines.push(`const ${namespaceSpec.local.name} = ${modIdent};`);
+      }
+      if (defaultSpec) {
+        let init = modIdent;
+        switch (opts.cjsDefault) {
+          case 'module-exports':
+            init = modIdent;
+            break;
+          case 'none':
+            init = `${modIdent}.default`;
+            break;
+          case 'auto':
+          default:
+            init = `${defaultInteropName}(${modIdent})`;
+            needsInterop = true;
+            break;
+        }
+        lines.push(`const ${defaultSpec.local.name} = ${init};`);
+      }
+      if (namedSpecs.length) {
+        const pairs = namedSpecs.map(s => {
+          const imported = s.imported.name;
+          const local = s.local.name;
+          return imported === local ? imported : `${imported}: ${local}`;
+        });
+        lines.push(`const { ${pairs.join(', ')} } = ${modIdent};`);
+      }
+      importTransforms.push({
+        start: node.start,
+        end: node.end,
+        code: `${lines.join('\n')}\n`,
+        needsInterop
+      });
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      // Handle declaration exports
+      if (node.declaration) {
+        const decl = node.declaration;
+        const declSrc = code.slice(decl.start, decl.end);
+        const exportedNames = [];
+        if (decl.type === 'VariableDeclaration') {
+          for (const d of decl.declarations) {
+            if (d.id.type === 'Identifier') {
+              exportedNames.push(d.id.name);
+            }
+          }
+        } else if (decl.id?.type === 'Identifier') {
+          exportedNames.push(decl.id.name);
+        }
+        const exportLines = exportedNames.map(name => exportAssignment(name, name, live));
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${declSrc}\n${exportLines.join('\n')}\n`
+        });
+        continue;
+      }
+
+      // Handle re-export or local specifiers
+      if (node.specifiers?.length) {
+        if (node.source) {
+          const srcLiteral = code.slice(node.source.start, node.source.end);
+          const modIdent = `__mod${importIndex++}`;
+          const lines = [`const ${modIdent} = require(${srcLiteral});`];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const imported = spec.local.name;
+            let rhs = `${modIdent}.${imported}`;
+            if (imported === 'default') {
+              rhs = `${defaultInteropName}(${modIdent})`;
+              needsInterop = true;
+            }
+            lines.push(exportAssignment(exported, rhs, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`,
+            needsInterop
+          });
+        } else {
+          const lines = [];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const local = spec.local.name;
+            lines.push(exportAssignment(exported, local, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`
+          });
+        }
+      }
+    }
+    if (node.type === 'ExportDefaultDeclaration') {
+      const decl = node.declaration;
+      const useExportsObject = containsTopLevelAwait && opts.topLevelAwait !== 'error';
+      if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+        if (decl.id?.name) {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${decl.id.name};` : `module.exports = ${decl.id.name};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${declSrc}\n${assign}\n`
+          });
+        } else {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${declSrc};` : `module.exports = ${declSrc};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${assign}\n`
+          });
+        }
+      } else {
+        const exprSrc = code.slice(decl.start, decl.end);
+        const assign = useExportsObject ? `exports.default = ${exprSrc};` : `module.exports = ${exprSrc};`;
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${assign}\n`
+        });
+      }
+    }
+    if (node.type === 'ExportAllDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      if (node.exported) {
+        const exported = node.exported.name;
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`, exportAssignment(exported, modIdent, live)];
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      } else {
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`];
+        const loop = `for (const k in ${modIdent}) {\n  if (k === 'default') continue;\n  if (!Object.prototype.hasOwnProperty.call(${modIdent}, k)) continue;\n  Object.defineProperty(exports, k, { enumerable: true, get: () => ${modIdent}[k] });\n}`;
+        lines.push(loop);
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      }
+    }
+  }
+  return {
+    importTransforms,
+    exportTransforms,
+    needsInterop
+  };
+};
 /**
  * Node added support for import.meta.main.
  * Added in: v24.2.0, v22.18.0
@@ -28,21 +335,67 @@ const format = async (src, ast, opts) => {
     hasDefaultExportBeenReassigned: false,
     hasDefaultExportBeenAssigned: false
   };
-  const exportTable = opts.target === 'module' ? await (0, _exports.collectCjsExports)(ast.program) : null;
-  await (0, _identifiers.collectModuleIdentifiers)(ast.program);
+  const moduleIdentifiers = await (0, _identifiers.collectModuleIdentifiers)(ast.program);
+  const shadowedBindings = new Set([...moduleIdentifiers.entries()].filter(([, meta]) => meta.declare.length > 0).map(([name]) => name));
   if (opts.target === 'module' && opts.transformSyntax) {
-    /**
-     * Prepare ESM output by renaming `exports` to `__exports` and seeding an
-     * `import.meta.filename` touch so import.meta is present even when the
-     * original source never referenced it.
-     */
-    code.prepend(`let ${_exports.exportsRename} = {};
-void import.meta.filename;
-`);
+    if (shadowedBindings.has('module') || shadowedBindings.has('exports')) {
+      throw new Error('Cannot transform to ESM: module or exports is shadowed in module scope.');
+    }
+  }
+  const exportTable = opts.target === 'module' ? await (0, _exports.collectCjsExports)(ast.program) : null;
+  const shouldCheckTopLevelAwait = opts.target === 'commonjs' && opts.transformSyntax;
+  const containsTopLevelAwait = shouldCheckTopLevelAwait ? hasTopLevelAwait(ast.program) : false;
+  const shouldLowerCjs = opts.target === 'commonjs' && opts.transformSyntax;
+  const shouldRaiseEsm = opts.target === 'module' && opts.transformSyntax;
+  let hoistedImports = [];
+  let pendingRequireTransforms = [];
+  let needsCreateRequire = false;
+  let pendingCjsTransforms = null;
+  if (shouldLowerCjs && opts.topLevelAwait === 'error' && containsTopLevelAwait) {
+    throw new Error('Top-level await is not supported when targeting CommonJS (set topLevelAwait to "wrap" or "preserve" to override).');
+  }
+  if (shouldRaiseEsm) {
+    const {
+      transforms,
+      imports,
+      needsCreateRequire: reqCreate
+    } = lowerCjsRequireToImports(ast.program, code, shadowedBindings);
+    pendingRequireTransforms = transforms;
+    hoistedImports = imports;
+    needsCreateRequire = reqCreate;
   }
   await (0, _walk.ancestorWalk)(ast.program, {
     async enter(node, ancestors) {
       const parent = ancestors[ancestors.length - 2] ?? null;
+      if (shouldRaiseEsm && node.type === 'BinaryExpression') {
+        const op = node.operator;
+        const isEquality = op === '===' || op === '==' || op === '!==' || op === '!=';
+        if (isEquality) {
+          const leftMain = isRequireMainMember(node.left, shadowedBindings);
+          const rightMain = isRequireMainMember(node.right, shadowedBindings);
+          const leftModule = node.left.type === 'Identifier' && node.left.name === 'module' && !shadowedBindings.has('module');
+          const rightModule = node.right.type === 'Identifier' && node.right.name === 'module' && !shadowedBindings.has('module');
+          if (leftMain && rightModule || rightMain && leftModule) {
+            const negate = op === '!==' || op === '!=';
+            code.update(node.start, node.end, negate ? '!import.meta.main' : 'import.meta.main');
+            return;
+          }
+        }
+      }
+      if (shouldRaiseEsm && node.type === 'CallExpression' && isRequireCall(node, shadowedBindings)) {
+        const isStatic = isStaticRequire(node, shadowedBindings);
+        const parent = ancestors[ancestors.length - 2] ?? null;
+        const grandparent = ancestors[ancestors.length - 3] ?? null;
+        const greatGrandparent = ancestors[ancestors.length - 4] ?? null;
+
+        // Hoistable cases are handled separately and don't need createRequire.
+        const topLevelExprStmt = parent?.type === 'ExpressionStatement' && grandparent?.type === 'Program';
+        const topLevelVarDecl = parent?.type === 'VariableDeclarator' && grandparent?.type === 'VariableDeclaration' && greatGrandparent?.type === 'Program';
+        const hoistableTopLevel = isStatic && (topLevelExprStmt || topLevelVarDecl);
+        if (!isStatic || !hoistableTopLevel) {
+          needsCreateRequire = true;
+        }
+      }
       if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
         const skipped = ['__filename', '__dirname'];
         const skippedParams = node.params.filter(param => param.type === 'Identifier' && skipped.includes(param.name));
@@ -101,7 +454,7 @@ void import.meta.filename;
         (0, _metaProperty.metaProperty)(node, parent, code, opts);
       }
       if (node.type === 'MemberExpression') {
-        (0, _memberExpression.memberExpression)(node, parent, code, opts);
+        (0, _memberExpression.memberExpression)(node, parent, code, opts, shadowedBindings);
       }
       if ((0, _identifier2.isIdentifierName)(node)) {
         (0, _identifier.identifier)({
@@ -109,11 +462,36 @@ void import.meta.filename;
           ancestors,
           code,
           opts,
-          meta: exportsMeta
+          meta: exportsMeta,
+          shadowed: shadowedBindings
         });
       }
     }
   });
+  if (pendingRequireTransforms.length) {
+    for (const t of pendingRequireTransforms) {
+      code.overwrite(t.start, t.end, t.code);
+    }
+  }
+  if (shouldLowerCjs) {
+    const {
+      importTransforms,
+      exportTransforms,
+      needsInterop
+    } = lowerEsmToCjs(ast.program, code, opts, containsTopLevelAwait);
+    pendingCjsTransforms = {
+      transforms: [...importTransforms, ...exportTransforms].sort((a, b) => a.start - b.start),
+      needsInterop
+    };
+  }
+  if (pendingCjsTransforms) {
+    for (const t of pendingCjsTransforms.transforms) {
+      code.overwrite(t.start, t.end, t.code);
+    }
+    if (pendingCjsTransforms.needsInterop) {
+      code.prepend(`${interopHelper}exports.__esModule = true;\n`);
+    }
+  }
   if (opts.target === 'module' && opts.transformSyntax && exportTable) {
     const isValidExportName = name => /^[$A-Z_a-z][$\w]*$/.test(name);
     const asExportName = name => isValidExportName(name) ? name : JSON.stringify(name);
@@ -143,6 +521,30 @@ void import.meta.filename;
       code.append(`\n${lines.join('\n')}\n`);
     }
   }
+  if (shouldRaiseEsm && opts.transformSyntax) {
+    const importPrelude = [];
+    if (needsCreateRequire) {
+      importPrelude.push('import { createRequire } from "node:module";\n');
+    }
+    if (hoistedImports.length) {
+      importPrelude.push(...hoistedImports);
+    }
+    const requireInit = needsCreateRequire ? 'const require = createRequire(import.meta.url);\n' : '';
+    const prelude = `${importPrelude.join('')}${importPrelude.length ? '\n' : ''}${requireInit}let ${_exports.exportsRename} = {};
+void import.meta.filename;
+`;
+    code.prepend(prelude);
+  }
+  if (opts.target === 'commonjs' && opts.transformSyntax && containsTopLevelAwait) {
+    const body = code.toString();
+    if (opts.topLevelAwait === 'wrap') {
+      const tlaPromise = `const __tla = (async () => {\n${body}\nreturn module.exports;\n})();\n`;
+      const setPromise = `const __setTla = target => {\n  if (!target) return;\n  const type = typeof target;\n  if (type !== 'object' && type !== 'function') return;\n  target.__tla = __tla;\n};\n`;
+      const attach = `__setTla(module.exports);\n__tla.then(resolved => __setTla(resolved), err => { throw err; });\n`;
+      return `${tlaPromise}${setPromise}${attach}`;
+    }
+    return `;(async () => {\n${body}\n})();\n`;
+  }
   return code.toString();
 };
 exports.format = format;

package/dist/cjs/formatters/identifier.cjs

@@ -11,7 +11,8 @@ const identifier = ({
   ancestors,
   code,
   opts,
-  meta
+  meta,
+  shadowed
 }) => {
   if (opts.target === 'module') {
     const {
@@ -19,6 +20,9 @@ const identifier = ({
       end,
       name
     } = node;
+    if (shadowed?.has(name)) {
+      return;
+    }
     switch (name) {
       case '__filename':
         code.update(start, end, 'import.meta.url');

package/dist/cjs/formatters/memberExpression.cjs

@@ -5,8 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.memberExpression = void 0;
 var _exports = require("#utils/exports.js");
-const memberExpression = (node, parent, src, options) => {
+const memberExpression = (node, parent, src, options, shadowed) => {
   if (options.target === 'module') {
+    if (node.object.type === 'Identifier' && shadowed?.has(node.object.name) || node.property.type === 'Identifier' && shadowed?.has(node.property.name)) {
+      return;
+    }
     if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'exports') {
       src.update(node.start, node.end, _exports.exportsRename);
       return;
@@ -23,18 +26,10 @@ const memberExpression = (node, parent, src, options) => {
       // CommonJS properties of `require`
       switch (name) {
         case 'main':
-          /**
-           * Node.js team still quibbling over import.meta.main ¯\_(ツ)_/¯
-           * @see https://github.com/nodejs/node/pull/32223
-           */
-          if (parent?.type === 'ExpressionStatement') {
-            // This is a standalone expression so remove it to not cause run-time errors.
-            src.remove(start, end);
+          if (parent?.type === 'BinaryExpression') {
+            return;
           }
-          /**
-           * Transform require.main === module.
-           */
-          if (parent?.type === 'BinaryExpression') {}
+          src.update(start, end, 'import.meta.main');
           break;
         case 'resolve':
           src.update(start, end, 'import.meta.resolve');
@@ -48,6 +43,11 @@ const memberExpression = (node, parent, src, options) => {
           break;
       }
     }
+    if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'require') {
+      if (!shadowed?.has('module')) {
+        src.update(node.start, node.end, 'require');
+      }
+    }
   }
 };
 exports.memberExpression = memberExpression;

package/dist/cjs/formatters/metaProperty.cjs

@@ -4,6 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.metaProperty = void 0;
+const importMetaMainSupport = '(() => { const [__nmaj, __nmin] = process.versions.node.split(".").map(n => parseInt(n, 10) || 0); return (__nmaj > 24 || (__nmaj === 24 && __nmin >= 2) || (__nmaj === 22 && __nmin >= 18)); })()';
+const importMetaMainShim = 'process.argv[1] === __filename';
+const importMetaMainExpr = mode => {
+  switch (mode) {
+    case 'warn':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (console.warn("import.meta.main is not supported before Node 22.18/24.2; falling back to shim."), ${importMetaMainShim}))`;
+    case 'error':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (() => { throw new Error("import.meta.main is not supported before Node 22.18/24.2"); })())`;
+    case 'shim':
+    default:
+      return importMetaMainShim;
+  }
+};
 const metaProperty = (node, parent, src, options) => {
   if (options.target === 'commonjs') {
     if (parent?.type !== 'MemberExpression') {
@@ -27,10 +40,15 @@ const metaProperty = (node, parent, src, options) => {
           break;
         case 'resolve':
           /**
-           * Should this be `require('node:url').pathToFileURL(require.resolve(<parsed specifier>)).href`?
+           * Map to require.resolve intentionally: matches CJS resolution semantics.
+           * Wrapping in pathToFileURL(...) would change the return shape (URL string)
+           * without truly emulating ESM import.meta.resolve rules.
            */
           src.update(parent.start, parent.end, 'require.resolve');
           break;
+        case 'main':
+          src.update(parent.start, parent.end, importMetaMainExpr(options.importMetaMain));
+          break;
       }
     }
   }

package/dist/cjs/memberExpression.d.cts

@@ -1,4 +1,4 @@
 import MagicString from 'magic-string';
 import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.cjs';
-export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>) => void;

package/dist/cjs/module.cjs

@@ -18,6 +18,7 @@ const defaultOptions = {
   rewriteSpecifier: undefined,
   dirFilename: 'inject',
   importMeta: 'shim',
+  importMetaMain: 'shim',
   requireSource: 'builtin',
   cjsDefault: 'auto',
   topLevelAwait: 'error',

package/dist/cjs/types.d.cts

@@ -8,6 +8,7 @@ export type ModuleOptions = {
     rewriteSpecifier?: RewriteSpecifier;
     dirFilename?: 'inject' | 'preserve' | 'error';
     importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
     requireSource?: 'builtin' | 'create-require';
     cjsDefault?: 'module-exports' | 'auto' | 'none';
     topLevelAwait?: 'error' | 'wrap' | 'preserve';

package/dist/format.js

@@ -8,7 +8,313 @@ import { exportsRename, collectCjsExports } from '#utils/exports.js';
 import { collectModuleIdentifiers } from '#utils/identifiers.js';
 import { isIdentifierName } from '#helpers/identifier.js';
 import { ancestorWalk } from '#walk';
+const isValidIdent = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+const exportAssignment = (name, expr, live) => {
+  const prop = isValidIdent(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+  if (live === 'strict') {
+    const key = JSON.stringify(name);
+    return `Object.defineProperty(exports, ${key}, { enumerable: true, get: () => ${expr} });`;
+  }
+  return `exports${prop} = ${expr};`;
+};
+const defaultInteropName = '__interopDefault';
+const interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const isRequireCallee = (callee, shadowed) => {
+  if (callee.type === 'Identifier' && callee.name === 'require' && !shadowed.has('require')) {
+    return true;
+  }
+  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'module' && !shadowed.has('module') && callee.property.type === 'Identifier' && callee.property.name === 'require') {
+    return true;
+  }
+  return false;
+};
+const isStaticRequire = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed) && node.arguments.length === 1 && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string';
+const isRequireCall = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed);
+const lowerCjsRequireToImports = (program, code, shadowed) => {
+  const transforms = [];
+  const imports = [];
+  let nsIndex = 0;
+  let needsCreateRequire = false;
+  for (const stmt of program.body) {
+    if (stmt.type === 'VariableDeclaration') {
+      const decls = stmt.declarations;
+      const allStatic = decls.length > 0 && decls.every(decl => decl.init && isStaticRequire(decl.init, shadowed));
+      if (allStatic) {
+        for (const decl of decls) {
+          const init = decl.init;
+          const source = code.slice(init.arguments[0].start, init.arguments[0].end);
+          if (decl.id.type === 'Identifier') {
+            imports.push(`import * as ${decl.id.name} from ${source};\n`);
+          } else if (decl.id.type === 'ObjectPattern') {
+            const ns = `__cjsImport${nsIndex++}`;
+            const pattern = code.slice(decl.id.start, decl.id.end);
+            imports.push(`import * as ${ns} from ${source};\n`);
+            imports.push(`const ${pattern} = ${ns};\n`);
+          } else {
+            needsCreateRequire = true;
+          }
+        }
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      for (const decl of decls) {
+        const init = decl.init;
+        if (init && isRequireCall(init, shadowed)) {
+          needsCreateRequire = true;
+        }
+      }
+    }
+    if (stmt.type === 'ExpressionStatement') {
+      const expr = stmt.expression;
+      if (expr && isStaticRequire(expr, shadowed)) {
+        const source = code.slice(expr.arguments[0].start, expr.arguments[0].end);
+        imports.push(`import ${source};\n`);
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      if (expr && isRequireCall(expr, shadowed)) {
+        needsCreateRequire = true;
+      }
+    }
+  }
+  return {
+    transforms,
+    imports,
+    needsCreateRequire
+  };
+};
+const isRequireMainMember = (node, shadowed) => node && node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'require' && !shadowed.has('require') && node.property.type === 'Identifier' && node.property.name === 'main';
+const hasTopLevelAwait = program => {
+  let found = false;
+  const walkNode = (node, inFunction) => {
+    if (found) return;
+    switch (node.type) {
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        inFunction = true;
+        break;
+    }
+    if (!inFunction && node.type === 'AwaitExpression') {
+      found = true;
+      return;
+    }
+    const keys = Object.keys(node);
+    for (const key of keys) {
+      const value = node[key];
+      if (!value) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object') {
+            walkNode(item, inFunction);
+            if (found) return;
+          }
+        }
+      } else if (value && typeof value === 'object') {
+        walkNode(value, inFunction);
+        if (found) return;
+      }
+    }
+  };
+  walkNode(program, false);
+  return found;
+};
+const lowerEsmToCjs = (program, code, opts, containsTopLevelAwait) => {
+  const live = opts.liveBindings ?? 'strict';
+  const importTransforms = [];
+  const exportTransforms = [];
+  let needsInterop = false;
+  let importIndex = 0;
+  for (const node of program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      const specifiers = node.specifiers ?? [];
+      const defaultSpec = specifiers.find(s => s.type === 'ImportDefaultSpecifier');
+      const namespaceSpec = specifiers.find(s => s.type === 'ImportNamespaceSpecifier');
+      const namedSpecs = specifiers.filter(s => s.type === 'ImportSpecifier');
 
+      // Side-effect import
+      if (!specifiers.length) {
+        importTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `require(${srcLiteral});\n`,
+          needsInterop: false
+        });
+        continue;
+      }
+      const modIdent = `__mod${importIndex++}`;
+      const lines = [];
+      lines.push(`const ${modIdent} = require(${srcLiteral});`);
+      if (namespaceSpec) {
+        lines.push(`const ${namespaceSpec.local.name} = ${modIdent};`);
+      }
+      if (defaultSpec) {
+        let init = modIdent;
+        switch (opts.cjsDefault) {
+          case 'module-exports':
+            init = modIdent;
+            break;
+          case 'none':
+            init = `${modIdent}.default`;
+            break;
+          case 'auto':
+          default:
+            init = `${defaultInteropName}(${modIdent})`;
+            needsInterop = true;
+            break;
+        }
+        lines.push(`const ${defaultSpec.local.name} = ${init};`);
+      }
+      if (namedSpecs.length) {
+        const pairs = namedSpecs.map(s => {
+          const imported = s.imported.name;
+          const local = s.local.name;
+          return imported === local ? imported : `${imported}: ${local}`;
+        });
+        lines.push(`const { ${pairs.join(', ')} } = ${modIdent};`);
+      }
+      importTransforms.push({
+        start: node.start,
+        end: node.end,
+        code: `${lines.join('\n')}\n`,
+        needsInterop
+      });
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      // Handle declaration exports
+      if (node.declaration) {
+        const decl = node.declaration;
+        const declSrc = code.slice(decl.start, decl.end);
+        const exportedNames = [];
+        if (decl.type === 'VariableDeclaration') {
+          for (const d of decl.declarations) {
+            if (d.id.type === 'Identifier') {
+              exportedNames.push(d.id.name);
+            }
+          }
+        } else if (decl.id?.type === 'Identifier') {
+          exportedNames.push(decl.id.name);
+        }
+        const exportLines = exportedNames.map(name => exportAssignment(name, name, live));
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${declSrc}\n${exportLines.join('\n')}\n`
+        });
+        continue;
+      }
+
+      // Handle re-export or local specifiers
+      if (node.specifiers?.length) {
+        if (node.source) {
+          const srcLiteral = code.slice(node.source.start, node.source.end);
+          const modIdent = `__mod${importIndex++}`;
+          const lines = [`const ${modIdent} = require(${srcLiteral});`];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const imported = spec.local.name;
+            let rhs = `${modIdent}.${imported}`;
+            if (imported === 'default') {
+              rhs = `${defaultInteropName}(${modIdent})`;
+              needsInterop = true;
+            }
+            lines.push(exportAssignment(exported, rhs, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`,
+            needsInterop
+          });
+        } else {
+          const lines = [];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const local = spec.local.name;
+            lines.push(exportAssignment(exported, local, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`
+          });
+        }
+      }
+    }
+    if (node.type === 'ExportDefaultDeclaration') {
+      const decl = node.declaration;
+      const useExportsObject = containsTopLevelAwait && opts.topLevelAwait !== 'error';
+      if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+        if (decl.id?.name) {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${decl.id.name};` : `module.exports = ${decl.id.name};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${declSrc}\n${assign}\n`
+          });
+        } else {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${declSrc};` : `module.exports = ${declSrc};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${assign}\n`
+          });
+        }
+      } else {
+        const exprSrc = code.slice(decl.start, decl.end);
+        const assign = useExportsObject ? `exports.default = ${exprSrc};` : `module.exports = ${exprSrc};`;
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${assign}\n`
+        });
+      }
+    }
+    if (node.type === 'ExportAllDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      if (node.exported) {
+        const exported = node.exported.name;
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`, exportAssignment(exported, modIdent, live)];
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      } else {
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`];
+        const loop = `for (const k in ${modIdent}) {\n  if (k === 'default') continue;\n  if (!Object.prototype.hasOwnProperty.call(${modIdent}, k)) continue;\n  Object.defineProperty(exports, k, { enumerable: true, get: () => ${modIdent}[k] });\n}`;
+        lines.push(loop);
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      }
+    }
+  }
+  return {
+    importTransforms,
+    exportTransforms,
+    needsInterop
+  };
+};
 /**
  * Node added support for import.meta.main.
  * Added in: v24.2.0, v22.18.0
@@ -22,21 +328,67 @@ const format = async (src, ast, opts) => {
     hasDefaultExportBeenReassigned: false,
     hasDefaultExportBeenAssigned: false
   };
-  const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
-  await collectModuleIdentifiers(ast.program);
+  const moduleIdentifiers = await collectModuleIdentifiers(ast.program);
+  const shadowedBindings = new Set([...moduleIdentifiers.entries()].filter(([, meta]) => meta.declare.length > 0).map(([name]) => name));
   if (opts.target === 'module' && opts.transformSyntax) {
-    /**
-     * Prepare ESM output by renaming `exports` to `__exports` and seeding an
-     * `import.meta.filename` touch so import.meta is present even when the
-     * original source never referenced it.
-     */
-    code.prepend(`let ${exportsRename} = {};
-void import.meta.filename;
-`);
+    if (shadowedBindings.has('module') || shadowedBindings.has('exports')) {
+      throw new Error('Cannot transform to ESM: module or exports is shadowed in module scope.');
+    }
+  }
+  const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
+  const shouldCheckTopLevelAwait = opts.target === 'commonjs' && opts.transformSyntax;
+  const containsTopLevelAwait = shouldCheckTopLevelAwait ? hasTopLevelAwait(ast.program) : false;
+  const shouldLowerCjs = opts.target === 'commonjs' && opts.transformSyntax;
+  const shouldRaiseEsm = opts.target === 'module' && opts.transformSyntax;
+  let hoistedImports = [];
+  let pendingRequireTransforms = [];
+  let needsCreateRequire = false;
+  let pendingCjsTransforms = null;
+  if (shouldLowerCjs && opts.topLevelAwait === 'error' && containsTopLevelAwait) {
+    throw new Error('Top-level await is not supported when targeting CommonJS (set topLevelAwait to "wrap" or "preserve" to override).');
+  }
+  if (shouldRaiseEsm) {
+    const {
+      transforms,
+      imports,
+      needsCreateRequire: reqCreate
+    } = lowerCjsRequireToImports(ast.program, code, shadowedBindings);
+    pendingRequireTransforms = transforms;
+    hoistedImports = imports;
+    needsCreateRequire = reqCreate;
   }
   await ancestorWalk(ast.program, {
     async enter(node, ancestors) {
       const parent = ancestors[ancestors.length - 2] ?? null;
+      if (shouldRaiseEsm && node.type === 'BinaryExpression') {
+        const op = node.operator;
+        const isEquality = op === '===' || op === '==' || op === '!==' || op === '!=';
+        if (isEquality) {
+          const leftMain = isRequireMainMember(node.left, shadowedBindings);
+          const rightMain = isRequireMainMember(node.right, shadowedBindings);
+          const leftModule = node.left.type === 'Identifier' && node.left.name === 'module' && !shadowedBindings.has('module');
+          const rightModule = node.right.type === 'Identifier' && node.right.name === 'module' && !shadowedBindings.has('module');
+          if (leftMain && rightModule || rightMain && leftModule) {
+            const negate = op === '!==' || op === '!=';
+            code.update(node.start, node.end, negate ? '!import.meta.main' : 'import.meta.main');
+            return;
+          }
+        }
+      }
+      if (shouldRaiseEsm && node.type === 'CallExpression' && isRequireCall(node, shadowedBindings)) {
+        const isStatic = isStaticRequire(node, shadowedBindings);
+        const parent = ancestors[ancestors.length - 2] ?? null;
+        const grandparent = ancestors[ancestors.length - 3] ?? null;
+        const greatGrandparent = ancestors[ancestors.length - 4] ?? null;
+
+        // Hoistable cases are handled separately and don't need createRequire.
+        const topLevelExprStmt = parent?.type === 'ExpressionStatement' && grandparent?.type === 'Program';
+        const topLevelVarDecl = parent?.type === 'VariableDeclarator' && grandparent?.type === 'VariableDeclaration' && greatGrandparent?.type === 'Program';
+        const hoistableTopLevel = isStatic && (topLevelExprStmt || topLevelVarDecl);
+        if (!isStatic || !hoistableTopLevel) {
+          needsCreateRequire = true;
+        }
+      }
       if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
         const skipped = ['__filename', '__dirname'];
         const skippedParams = node.params.filter(param => param.type === 'Identifier' && skipped.includes(param.name));
@@ -95,7 +447,7 @@ void import.meta.filename;
         metaProperty(node, parent, code, opts);
       }
       if (node.type === 'MemberExpression') {
-        memberExpression(node, parent, code, opts);
+        memberExpression(node, parent, code, opts, shadowedBindings);
       }
       if (isIdentifierName(node)) {
         identifier({
@@ -103,11 +455,36 @@ void import.meta.filename;
           ancestors,
           code,
           opts,
-          meta: exportsMeta
+          meta: exportsMeta,
+          shadowed: shadowedBindings
         });
       }
     }
   });
+  if (pendingRequireTransforms.length) {
+    for (const t of pendingRequireTransforms) {
+      code.overwrite(t.start, t.end, t.code);
+    }
+  }
+  if (shouldLowerCjs) {
+    const {
+      importTransforms,
+      exportTransforms,
+      needsInterop
+    } = lowerEsmToCjs(ast.program, code, opts, containsTopLevelAwait);
+    pendingCjsTransforms = {
+      transforms: [...importTransforms, ...exportTransforms].sort((a, b) => a.start - b.start),
+      needsInterop
+    };
+  }
+  if (pendingCjsTransforms) {
+    for (const t of pendingCjsTransforms.transforms) {
+      code.overwrite(t.start, t.end, t.code);
+    }
+    if (pendingCjsTransforms.needsInterop) {
+      code.prepend(`${interopHelper}exports.__esModule = true;\n`);
+    }
+  }
   if (opts.target === 'module' && opts.transformSyntax && exportTable) {
     const isValidExportName = name => /^[$A-Z_a-z][$\w]*$/.test(name);
     const asExportName = name => isValidExportName(name) ? name : JSON.stringify(name);
@@ -137,6 +514,30 @@ void import.meta.filename;
       code.append(`\n${lines.join('\n')}\n`);
     }
   }
+  if (shouldRaiseEsm && opts.transformSyntax) {
+    const importPrelude = [];
+    if (needsCreateRequire) {
+      importPrelude.push('import { createRequire } from "node:module";\n');
+    }
+    if (hoistedImports.length) {
+      importPrelude.push(...hoistedImports);
+    }
+    const requireInit = needsCreateRequire ? 'const require = createRequire(import.meta.url);\n' : '';
+    const prelude = `${importPrelude.join('')}${importPrelude.length ? '\n' : ''}${requireInit}let ${exportsRename} = {};
+void import.meta.filename;
+`;
+    code.prepend(prelude);
+  }
+  if (opts.target === 'commonjs' && opts.transformSyntax && containsTopLevelAwait) {
+    const body = code.toString();
+    if (opts.topLevelAwait === 'wrap') {
+      const tlaPromise = `const __tla = (async () => {\n${body}\nreturn module.exports;\n})();\n`;
+      const setPromise = `const __setTla = target => {\n  if (!target) return;\n  const type = typeof target;\n  if (type !== 'object' && type !== 'function') return;\n  target.__tla = __tla;\n};\n`;
+      const attach = `__setTla(module.exports);\n__tla.then(resolved => __setTla(resolved), err => { throw err; });\n`;
+      return `${tlaPromise}${setPromise}${attach}`;
+    }
+    return `;(async () => {\n${body}\n})();\n`;
+  }
   return code.toString();
 };
 export { format };

package/dist/formatters/identifier.js

@@ -5,7 +5,8 @@ export const identifier = ({
   ancestors,
   code,
   opts,
-  meta
+  meta,
+  shadowed
 }) => {
   if (opts.target === 'module') {
     const {
@@ -13,6 +14,9 @@ export const identifier = ({
       end,
       name
     } = node;
+    if (shadowed?.has(name)) {
+      return;
+    }
     switch (name) {
       case '__filename':
         code.update(start, end, 'import.meta.url');

package/dist/formatters/memberExpression.js

@@ -1,6 +1,9 @@
 import { exportsRename } from '#utils/exports.js';
-export const memberExpression = (node, parent, src, options) => {
+export const memberExpression = (node, parent, src, options, shadowed) => {
   if (options.target === 'module') {
+    if (node.object.type === 'Identifier' && shadowed?.has(node.object.name) || node.property.type === 'Identifier' && shadowed?.has(node.property.name)) {
+      return;
+    }
     if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'exports') {
       src.update(node.start, node.end, exportsRename);
       return;
@@ -17,18 +20,10 @@ export const memberExpression = (node, parent, src, options) => {
       // CommonJS properties of `require`
       switch (name) {
         case 'main':
-          /**
-           * Node.js team still quibbling over import.meta.main ¯\_(ツ)_/¯
-           * @see https://github.com/nodejs/node/pull/32223
-           */
-          if (parent?.type === 'ExpressionStatement') {
-            // This is a standalone expression so remove it to not cause run-time errors.
-            src.remove(start, end);
+          if (parent?.type === 'BinaryExpression') {
+            return;
           }
-          /**
-           * Transform require.main === module.
-           */
-          if (parent?.type === 'BinaryExpression') {}
+          src.update(start, end, 'import.meta.main');
           break;
         case 'resolve':
           src.update(start, end, 'import.meta.resolve');
@@ -42,5 +37,10 @@ export const memberExpression = (node, parent, src, options) => {
           break;
       }
     }
+    if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'require') {
+      if (!shadowed?.has('module')) {
+        src.update(node.start, node.end, 'require');
+      }
+    }
   }
 };

package/dist/formatters/metaProperty.js

@@ -1,3 +1,16 @@
+const importMetaMainSupport = '(() => { const [__nmaj, __nmin] = process.versions.node.split(".").map(n => parseInt(n, 10) || 0); return (__nmaj > 24 || (__nmaj === 24 && __nmin >= 2) || (__nmaj === 22 && __nmin >= 18)); })()';
+const importMetaMainShim = 'process.argv[1] === __filename';
+const importMetaMainExpr = mode => {
+  switch (mode) {
+    case 'warn':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (console.warn("import.meta.main is not supported before Node 22.18/24.2; falling back to shim."), ${importMetaMainShim}))`;
+    case 'error':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (() => { throw new Error("import.meta.main is not supported before Node 22.18/24.2"); })())`;
+    case 'shim':
+    default:
+      return importMetaMainShim;
+  }
+};
 export const metaProperty = (node, parent, src, options) => {
   if (options.target === 'commonjs') {
     if (parent?.type !== 'MemberExpression') {
@@ -21,10 +34,15 @@ export const metaProperty = (node, parent, src, options) => {
           break;
         case 'resolve':
           /**
-           * Should this be `require('node:url').pathToFileURL(require.resolve(<parsed specifier>)).href`?
+           * Map to require.resolve intentionally: matches CJS resolution semantics.
+           * Wrapping in pathToFileURL(...) would change the return shape (URL string)
+           * without truly emulating ESM import.meta.resolve rules.
            */
           src.update(parent.start, parent.end, 'require.resolve');
           break;
+        case 'main':
+          src.update(parent.start, parent.end, importMetaMainExpr(options.importMetaMain));
+          break;
       }
     }
   }

package/dist/memberExpression.d.ts

@@ -1,4 +1,4 @@
 import MagicString from 'magic-string';
 import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.js';
-export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>) => void;

package/dist/module.js

@@ -12,6 +12,7 @@ const defaultOptions = {
   rewriteSpecifier: undefined,
   dirFilename: 'inject',
   importMeta: 'shim',
+  importMetaMain: 'shim',
   requireSource: 'builtin',
   cjsDefault: 'auto',
   topLevelAwait: 'error',

package/dist/src/formatters/identifier.d.ts

@@ -7,6 +7,7 @@ type IdentifierArg = {
     code: MagicString;
     opts: FormatterOptions;
     meta: ExportsMeta;
+    shadowed?: Set<string>;
 };
-export declare const identifier: ({ node, ancestors, code, opts, meta }: IdentifierArg) => void;
+export declare const identifier: ({ node, ancestors, code, opts, meta, shadowed, }: IdentifierArg) => void;
 export {};

package/dist/src/formatters/memberExpression.d.ts

@@ -1,4 +1,4 @@
 import MagicString from 'magic-string';
 import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.js';
-export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>) => void;

package/dist/src/types.d.ts

@@ -8,6 +8,7 @@ export type ModuleOptions = {
     rewriteSpecifier?: RewriteSpecifier;
     dirFilename?: 'inject' | 'preserve' | 'error';
     importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
     requireSource?: 'builtin' | 'create-require';
     cjsDefault?: 'module-exports' | 'auto' | 'none';
     topLevelAwait?: 'error' | 'wrap' | 'preserve';

package/dist/types.d.ts

@@ -8,6 +8,7 @@ export type ModuleOptions = {
     rewriteSpecifier?: RewriteSpecifier;
     dirFilename?: 'inject' | 'preserve' | 'error';
     importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
     requireSource?: 'builtin' | 'create-require';
     cjsDefault?: 'module-exports' | 'auto' | 'none';
     topLevelAwait?: 'error' | 'wrap' | 'preserve';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Transforms differences between ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",