repl: remove dependency on domain module

Replace the domain-based error handling with AsyncLocalStorage and
setUncaughtExceptionCaptureCallback. This removes the REPL's dependency
on the deprecated domain module while preserving all existing behavior:

- Synchronous errors during eval are caught and displayed
- Async errors (setTimeout, promises, etc.) are caught via the
  uncaught exception capture callback
- Top-level await errors are caught and displayed
- The REPL continues operating after errors
- Multiple REPL instances can coexist with errors routed correctly

Changes:
- Use AsyncLocalStorage to track which REPL instance owns an async
  context, replacing domain's automatic async tracking
- Add setupExceptionCapture() to install
  setUncaughtExceptionCaptureCallback for catching async errors and
  routing them to the correct REPL
- Extract error handling logic into REPLServer.prototype._handleError()
- Wrap eval execution in replContext.run() for async context tracking
- Update newListener protection to check AsyncLocalStorage context
- Throw ERR_INVALID_ARG_VALUE if options.domain is passed

PR-URL: #61227

Author: mcollina

lib/repl.js

@@ -2,9 +2,8 @@
 
 const ArrayStream = require('../common/arraystream');
 const repl = require('node:repl');
-const assert = require('node:assert');
 
-function startNewREPLServer(replOpts = {}, testingOpts = {}) {
+function startNewREPLServer(replOpts = {}) {
   const input = new ArrayStream();
   const output = new ArrayStream();
 
@@ -20,11 +19,6 @@ function startNewREPLServer(replOpts = {}, testingOpts = {}) {
     ...replOpts,
   });
 
-  if (!testingOpts.disableDomainErrorAssert) {
-    // Some errors are passed to the domain, but do not callback
-    replServer._domain.on('error', assert.ifError);
-  }
-
   return { replServer, input, output };
 }
 

test/common/repl.js

@@ -1,6 +1,5 @@
 // Tab completion sometimes uses a separate REPL instance under the hood.
-// That REPL instance has its own domain. Make sure domain errors trickle back
-// up to the main REPL.
+// Make sure errors in completion callbacks are properly thrown.
 //
 // Ref: https://github.com/nodejs/node/issues/21586
 
@@ -31,11 +30,6 @@ const repl = require('repl');
 const putIn = new ArrayStream();
 const testMe = repl.start('', putIn);
 
-// Some errors are passed to the domain, but do not callback.
-testMe._domain.on('error', function(err) {
-  throw err;
-});
-
 // Nesting of structures causes REPL to use a nested REPL for completion.
 putIn.run([
   'var top = function() {',

test/fixtures/repl-tab-completion-nested-repls.js

@@ -20,8 +20,6 @@ const assert = require('node:assert');
         eval$.resolve();
       });
     },
-  }, {
-    disableDomainErrorAssert: true,
   });
 
   replServer.write('\n');

test/parallel/test-repl-domain.js

@@ -3,5 +3,5 @@ require('../common');
 const { startNewREPLServer } = require('../common/repl');
 
 // Regression test for https://github.com/nodejs/node/issues/6802
-const { input } = startNewREPLServer({ useGlobal: true }, { disableDomainErrorAssert: true });
+const { input } = startNewREPLServer({ useGlobal: true });
 input.run(['let process']);

test/parallel/test-repl-eval-error-after-close.js

@@ -30,8 +30,8 @@ function testSloppyMode() {
 }
 
 function testStrictMode() {
-  const { input, output } = startNewREPLServer({ replMode: repl.REPL_MODE_STRICT, terminal: false, prompt: '> ' }, {
-    disableDomainErrorAssert: true,
+  const { input, output } = startNewREPLServer({
+    replMode: repl.REPL_MODE_STRICT, terminal: false, prompt: '> '
   });
 
   input.emit('data', 'x = 3\n');

test/parallel/test-repl-let-process.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// This test verifies that when multiple REPL instances exist concurrently,
+// async errors are correctly routed to the REPL instance that created them.
+
+const common = require('../common');
+const assert = require('assert');
+const repl = require('repl');
+const { Writable, PassThrough } = require('stream');
+
+// Create two REPLs with separate inputs and outputs
+let output1 = '';
+let output2 = '';
+
+const input1 = new PassThrough();
+const input2 = new PassThrough();
+
+const writable1 = new Writable({
+  write(chunk, encoding, callback) {
+    output1 += chunk.toString();
+    callback();
+  }
+});
+
+const writable2 = new Writable({
+  write(chunk, encoding, callback) {
+    output2 += chunk.toString();
+    callback();
+  }
+});
+
+const r1 = repl.start({
+  input: input1,
+  output: writable1,
+  terminal: false,
+  prompt: 'R1> ',
+});
+
+const r2 = repl.start({
+  input: input2,
+  output: writable2,
+  terminal: false,
+  prompt: 'R2> ',
+});
+
+// Create async error in REPL 1
+input1.write('setTimeout(() => { throw new Error("error from repl1") }, 10)\n');
+
+// Create async error in REPL 2
+input2.write('setTimeout(() => { throw new Error("error from repl2") }, 20)\n');
+
+setTimeout(common.mustCall(() => {
+  r1.close();
+  r2.close();
+
+  // Verify error from REPL 1 went to REPL 1's output
+  assert.match(output1, /error from repl1/,
+               'REPL 1 should have received its own async error');
+
+  // Verify error from REPL 2 went to REPL 2's output
+  assert.match(output2, /error from repl2/,
+               'REPL 2 should have received its own async error');
+
+  // Verify errors did not cross over to wrong REPL
+  assert.doesNotMatch(output1, /error from repl2/,
+                      'REPL 1 should not have received REPL 2\'s error');
+  assert.doesNotMatch(output2, /error from repl1/,
+                      'REPL 2 should not have received REPL 1\'s error');
+}), 100);

test/parallel/test-repl-mode.js

@@ -10,8 +10,6 @@ function run({ command, expected }) {
   const { replServer, output } = startNewREPLServer({
     terminal: false,
     useColors: false
-  }, {
-    disableDomainErrorAssert: true,
   });
 
   replServer.write(`${command}\n`);

test/parallel/test-repl-multiple-instances-async-error.js

@@ -5,10 +5,7 @@ const { startNewREPLServer } = require('../common/repl');
 
 const testingReplPrompt = '_REPL_TESTING_PROMPT_>';
 
-const { replServer, output } = startNewREPLServer(
-  { prompt: testingReplPrompt },
-  { disableDomainErrorAssert: true }
-);
+const { replServer, output } = startNewREPLServer({ prompt: testingReplPrompt });
 
 replServer.write('throw new Error("foo[a]")\n');