diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 63e76a27fab182..f85c224898db30 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -14,6 +14,3 @@ Contributors guide: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
 - [ ] tests and/or benchmarks are included
 - [ ] documentation is changed or added
 - [ ] commit message follows [commit guidelines](https://github.com/nodejs/node/blob/master/doc/guides/contributing/pull-requests.md#commit-message-guidelines)
-
-##### Affected core subsystem(s)
-<!-- Provide affected core subsystem(s) (like doc, cluster, crypto, etc). -->
diff --git a/doc/api/addons.md b/doc/api/addons.md
index 03feb8ec619ed5..d2f312b06e72fb 100644
--- a/doc/api/addons.md
+++ b/doc/api/addons.md
@@ -34,8 +34,9 @@ involving knowledge of several components and APIs :
 
  - Node.js includes a number of other statically linked libraries including
    OpenSSL. These other libraries are located in the `deps/` directory in the
-   Node.js source tree. Only the V8 and OpenSSL symbols are purposefully
-   re-exported by Node.js and may be used to various extents by Addons.
+   Node.js source tree. Only the libuv, OpenSSL, V8 and zlib symbols are
+   purposefully re-exported by Node.js and may be used to various extents by
+   Addons.
    See [Linking to Node.js' own dependencies][] for additional information.
 
 All of the following examples are available for [download][] and may
diff --git a/doc/api/assert.md b/doc/api/assert.md
index a859408a8be99e..3478adbfaf2e28 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -191,6 +191,11 @@ changes:
 Asserts that the function `block` does not throw an error. See
 [`assert.throws()`][] for more details.
 
+Please note: Using `assert.doesNotThrow()` is actually not useful because there
+is no benefit by catching an error and then rethrowing it. Instead, consider
+adding a comment next to the specific code path that should not throw and keep
+error messages as expressive as possible.
+
 When `assert.doesNotThrow()` is called, it will immediately call the `block`
 function.
 
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 3fbdfc34726fe6..a50640477dcfa1 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -2238,8 +2238,19 @@ changes:
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous rename(2). No arguments other than a possible exception are given
-to the completion callback.
+Asynchronously rename file at `oldPath` to the pathname provided
+as `newPath`. In the case that `newPath` already exists, it will
+be overwritten. No arguments other than a possible exception are
+given to the completion callback.
+
+See also: rename(2).
+
+```js
+fs.rename('oldFile.txt', 'newFile.txt', (err) => {
+  if (err) throw err;
+  console.log('Rename complete!');
+});
+```
 
 ## fs.renameSync(oldPath, newPath)
 <!-- YAML
diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index b6f702f0dd5b60..c801510b7563f2 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -136,8 +136,34 @@ with an error. [`session.connect()`] will need to be called to be able to send
 messages again. Reconnected session will lose all inspector state, such as
 enabled agents or configured breakpoints.
 
+## Example usage
+
+### CPU Profiler
+
+Apart from the debugger, various V8 Profilers are available through the DevTools
+protocol. Here's a simple example showing how to use the [CPU profiler][]:
+
+```js
+const inspector = require('inspector');
+
+const session = new inspector.Session();
+session.connect();
+
+session.post('Profiler.enable', () => {
+  session.post('Profiler.start', () => {
+    // invoke business logic under measurement here...
+
+    // some time later...
+    session.post('Profiler.stop', ({ profile }) => {
+      // write profile to disk, upload, etc.
+    });
+  });
+});
+```
+
 
 [`session.connect()`]: #inspector_session_connect
 [`Debugger.paused`]: https://chromedevtools.github.io/devtools-protocol/v8/Debugger/#event-paused
 [`EventEmitter`]: events.html#events_class_eventemitter
 [Chrome DevTools Protocol Viewer]: https://chromedevtools.github.io/devtools-protocol/v8/
+[CPU Profiler]: https://chromedevtools.github.io/devtools-protocol/v8/Profiler
diff --git a/doc/api/intl.md b/doc/api/intl.md
index 83a9947dc21238..147ef38664076e 100644
--- a/doc/api/intl.md
+++ b/doc/api/intl.md
@@ -19,6 +19,7 @@ programs. Some of them are:
 - [`require('buffer').transcode()`][]
 - More accurate [REPL][] line editing
 - [`require('util').TextDecoder`][]
+- [RegExp Unicode Property Escapes][]
 
 Node.js (and its underlying V8 engine) uses [ICU][] to implement these features
 in native C/C++ code. However, some of them require a very large ICU data file
@@ -55,6 +56,7 @@ option:
 | [`require('buffer').transcode()`][]     | none (function does not exist)    | full                         | full                   | full       |
 | [REPL][]                                | partial (inaccurate line editing) | full                         | full                   | full       |
 | [`require('util').TextDecoder`][]       | partial (basic encodings support) | partial/full (depends on OS) | partial (Unicode-only) | full       |
+| [RegExp Unicode Property Escapes][]     | none (invalid RegExp error)       | full                         | full                   | full       |
 
 *Note*: The "(not locale-aware)" designation denotes that the function carries
 out its operation just like the non-`Locale` version of the function, if one
@@ -207,6 +209,7 @@ to be helpful:
 [ECMA-402]: https://tc39.github.io/ecma402/
 [ICU]: http://icu-project.org/
 [REPL]: repl.html#repl_repl
+[RegExp Unicode Property Escapes]: https://github.com/tc39/proposal-regexp-unicode-property-escapes
 [Test262]: https://github.com/tc39/test262/tree/master/test/intl402
 [WHATWG URL parser]: url.html#url_the_whatwg_url_api
 [btest402]: https://github.com/srl295/btest402
diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md
index c1ca15718dc5d4..4a1eeaf98199ec 100644
--- a/doc/api/perf_hooks.md
+++ b/doc/api/perf_hooks.md
@@ -181,7 +181,8 @@ added: v8.5.0
 
 * Returns: {number}
 
-Returns the current high resolution millisecond timestamp.
+Returns the current high resolution millisecond timestamp, where 0 represents
+the start of the current `node` process.
 
 ### performance.timeOrigin
 <!-- YAML
@@ -190,8 +191,8 @@ added: v8.5.0
 
 * {number}
 
-The [`timeOrigin`][] specifies the high resolution millisecond timestamp from
-which all performance metric durations are measured.
+The [`timeOrigin`][] specifies the high resolution millisecond timestamp at
+which the current `node` process began, measured in Unix time.
 
 ### performance.timerify(fn)
 <!-- YAML
@@ -302,7 +303,8 @@ added: v8.5.0
 * {number}
 
 The high resolution millisecond timestamp at which the Node.js process
-completed bootstrap.
+completed bootstrapping. If bootstrapping has not yet finished, the property
+has the value of -1.
 
 ### performanceNodeTiming.clusterSetupEnd
 <!-- YAML
@@ -311,7 +313,8 @@ added: v8.5.0
 
 * {number}
 
-The high resolution millisecond timestamp at which cluster processing ended.
+The high resolution millisecond timestamp at which cluster processing ended. If
+cluster processing has not yet ended, the property has the value of -1.
 
 ### performanceNodeTiming.clusterSetupStart
 <!-- YAML
@@ -321,6 +324,7 @@ added: v8.5.0
 * {number}
 
 The high resolution millisecond timestamp at which cluster processing started.
+If cluster processing has not yet started, the property has the value of -1.
 
 ### performanceNodeTiming.loopExit
 <!-- YAML
@@ -330,7 +334,8 @@ added: v8.5.0
 * {number}
 
 The high resolution millisecond timestamp at which the Node.js event loop
-exited.
+exited. If the event loop has not yet exited, the property has the value of -1.
+It can only have a value of not -1 in a handler of the [`'exit'`][] event.
 
 ### performanceNodeTiming.loopStart
 <!-- YAML
@@ -340,7 +345,8 @@ added: v8.5.0
 * {number}
 
 The high resolution millisecond timestamp at which the Node.js event loop
-started.
+started. If the event loop has not yet started (e.g., in the first tick of the
+main script), the property has the value of -1.
 
 ### performanceNodeTiming.moduleLoadEnd
 <!-- YAML
@@ -395,8 +401,9 @@ added: v8.5.0
 
 * {number}
 
-The high resolution millisecond timestamp at which third_party_main processing
-ended.
+The high resolution millisecond timestamp at which third\_party\_main
+processing ended. If third\_party\_main processing has not yet ended, the
+property has the value of -1.
 
 ### performanceNodeTiming.thirdPartyMainStart
 <!-- YAML
@@ -405,8 +412,9 @@ added: v8.5.0
 
 * {number}
 
-The high resolution millisecond timestamp at which third_party_main processing
-started.
+The high resolution millisecond timestamp at which third\_party\_main
+processing started. If third\_party\_main processing has not yet started, the
+property has the value of -1.
 
 ### performanceNodeTiming.v8Start
 <!-- YAML
@@ -642,6 +650,7 @@ obs.observe({ entryTypes: ['function'], buffered: true });
 require('some-module');
 ```
 
+[`'exit'`]: process.html#process_event_exit
 [`timeOrigin`]: https://w3c.github.io/hr-time/#dom-performance-timeorigin
 [Async Hooks]: async_hooks.html
 [W3C Performance Timeline]: https://w3c.github.io/performance-timeline/
diff --git a/doc/api/process.md b/doc/api/process.md
index 574fc933671d14..a56bd36b5a2931 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -349,6 +349,9 @@ Signal events will be emitted when the Node.js process receives a signal. Please
 refer to signal(7) for a listing of standard POSIX signal names such as
 `SIGINT`, `SIGHUP`, etc.
 
+The signal handler will receive the signal's name (`'SIGINT'`,
+ `'SIGTERM'`, etc.) as the first argument.
+
 The name of each event will be the uppercase common name for the signal (e.g.
 `'SIGINT'` for `SIGINT` signals).
 
@@ -361,6 +364,14 @@ process.stdin.resume();
 process.on('SIGINT', () => {
   console.log('Received SIGINT. Press Control-D to exit.');
 });
+
+// Using a single function to handle multiple signals
+function handle(signal) {
+  console.log(`Received ${signal}`);
+}
+
+process.on('SIGINT', handle);
+process.on('SIGTERM', handle);
 ```
 
 * `SIGUSR1` is reserved by Node.js to start the [debugger][]. It's possible to
@@ -620,7 +631,17 @@ process.
 ```js
 console.log(`Current directory: ${process.cwd()}`);
 ```
+## process.debugPort
+<!-- YAML
+added: v0.7.2
+-->
+* {number}
+
+The port used by Node.js's debugger when enabled.
 
+```js
+process.debugPort = 5858;
+```
 ## process.disconnect()
 <!-- YAML
 added: v0.7.2
diff --git a/doc/api/stream.md b/doc/api/stream.md
index f0d393543d6516..6b51585e691f93 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -323,6 +323,9 @@ The `'unpipe'` event is emitted when the [`stream.unpipe()`][] method is called
 on a [Readable][] stream, removing this [Writable][] from its set of
 destinations.
 
+This is also emitted in case this [Writable][] stream emits an error when a
+[Readable][] stream pipes into it.
+
 ```js
 const writer = getWritableStreamSomehow();
 const reader = getReadableStreamSomehow();
@@ -931,10 +934,6 @@ readable.on('readable', () => {
 });
 ```
 
-In general, it is recommended that developers avoid the use of the `'readable'`
-event and the `readable.read()` method in favor of using either
-`readable.pipe()` or the `'data'` event.
-
 A Readable stream in object mode will always return a single item from
 a call to [`readable.read(size)`][stream-read], regardless of the value of the
 `size` argument.
@@ -1485,6 +1484,9 @@ the callback and passing the error as the first argument. This will cause an
 on how the stream is being used. Using the callback ensures consistent and
 predictable handling of errors.
 
+If a Readable stream pipes into a Writable stream when Writable emits an
+error, the Readable stream will be unpiped.
+
 ```js
 const { Writable } = require('stream');
 
@@ -1740,6 +1742,10 @@ class SourceWrapper extends Readable {
 *Note*: The `readable.push()` method is intended be called only by Readable
 Implementers, and only from within the `readable._read()` method.
 
+For streams not operating in object mode, if the `chunk` parameter of
+`readable.push()` is `undefined`, it will be treated as empty string or
+buffer. See [`readable.push('')`][] for more information.
+
 #### Errors While Reading
 
 It is recommended that errors occurring during the processing of the
@@ -2259,6 +2265,7 @@ contain multi-byte characters.
 [`stream.uncork()`]: #stream_writable_uncork
 [`stream.unpipe()`]: #stream_readable_unpipe_destination
 [`stream.wrap()`]: #stream_readable_wrap_stream
+[`readable.push('')`]: #stream_readable_push
 [`writable.cork()`]: #stream_writable_cork
 [`writable.uncork()`]: #stream_writable_uncork
 [`zlib.createDeflate()`]: zlib.html#zlib_zlib_createdeflate_options
diff --git a/doc/api/url.md b/doc/api/url.md
index 55649313b3a2e4..4d7fb9c8f45b83 100644
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -971,6 +971,20 @@ changes:
 The `url.format()` method returns a formatted URL string derived from
 `urlObject`.
 
+```js
+url.format({
+  protocol: 'https',
+  hostname: 'example.com',
+  pathname: '/some/path',
+  query: {
+    page: 1,
+    format: 'json'
+  }
+});
+
+// => 'https://example.com/some/path?page=1&format=json'
+```
+
 If `urlObject` is not an object or a string, `url.format()` will throw a
 [`TypeError`][].
 
diff --git a/doc/guides/contributing/pull-requests.md b/doc/guides/contributing/pull-requests.md
index 4fd2de923a0e48..7ac8389e313349 100644
--- a/doc/guides/contributing/pull-requests.md
+++ b/doc/guides/contributing/pull-requests.md
@@ -401,10 +401,10 @@ seem unfamiliar, refer to this
 All Pull Requests require "sign off" in order to land. Whenever a contributor
 reviews a Pull Request they may find specific details that they would like to
 see changed or fixed. These may be as simple as fixing a typo, or may involve
-substantive changes to the code you have written. In general, such requests
-are intended to be helpful, but at times may come across as abrupt or unhelpful,
-especially requests to change things that do not include concrete suggestions
-on *how* to change them.
+substantive changes to the code you have written. While such requests are
+intended to be helpful, they may come across as abrupt or unhelpful, especially
+requests to change things that do not include concrete suggestions on *how* to
+change them.
 
 Try not to be discouraged. If you feel that a particular review is unfair,
 say so, or contact one of the other contributors in the project and seek their
@@ -610,8 +610,8 @@ however, will stay intact on the Pull Request page.
 For the size of "one logical change",
 [0b5191f](https://github.com/nodejs/node/commit/0b5191f15d0f311c804d542b67e2e922d98834f8)
 can be a good example. It touches the implementation, the documentation,
-and the tests, but is still one logical change. In general, the tests should
-always pass when each individual commit lands on the master branch.
+and the tests, but is still one logical change. All tests should always pass
+when each individual commit lands on the master branch.
 
 ### Getting Approvals for Your Pull Request
 
diff --git a/doc/guides/maintaining-V8.md b/doc/guides/maintaining-V8.md
index 30300d402b3a9a..443885f7bcc60d 100644
--- a/doc/guides/maintaining-V8.md
+++ b/doc/guides/maintaining-V8.md
@@ -3,15 +3,14 @@
 ## Background
 
 V8 follows the Chromium release schedule. The support horizon for Chromium is
-very different from the support horizon that Node.js needs to provide to its
-users. As a result Node.js needs to support a version of V8 for quite a bit
-longer than what upstream needs to support. Since V8 doesn't have an LTS
-supported branch, there is no official process around how the V8 branches in
-Node.js are maintained.
-
-This document attempts to document the current processes and proposes a workflow
-for maintaining the V8 branches in Node.js LTS and Current releases and how the
-Node.js and V8 teams at Google can help.
+different compared to the support horizon for Node.js. As a result, Node.js
+needs to support multiple versions of V8 longer than what upstream needs
+to support. V8 branches in Node.js lack of an official maintenance process due
+to a missing LTS supported branch.
+
+This document attempts to outline the current maintenance processes, proposes
+a workflow for maintaining the V8 branches in both Node.js LTS and current
+releases, and discusses how the Node.js and V8 teams at Google can help.
 
 ## V8 Release Schedule
 
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 135d31acaaec2d..460521c8ded85c 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -350,7 +350,7 @@ function socketCloseListener() {
   req.emit('close');
   if (req.res && req.res.readable) {
     // Socket closed before we emitted 'end' below.
-    req.res.emit('aborted');
+    if (!req.res.complete) req.res.emit('aborted');
     var res = req.res;
     res.on('end', function() {
       res.emit('close');
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
index 46838304a39cfd..7718dad60a9cd2 100644
--- a/lib/async_hooks.js
+++ b/lib/async_hooks.js
@@ -48,15 +48,15 @@ const {
 class AsyncHook {
   constructor({ init, before, after, destroy, promiseResolve }) {
     if (init !== undefined && typeof init !== 'function')
-      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'init');
+      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'hook.init');
     if (before !== undefined && typeof before !== 'function')
-      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'before');
+      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'hook.before');
     if (after !== undefined && typeof after !== 'function')
-      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'before');
+      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'hook.after');
     if (destroy !== undefined && typeof destroy !== 'function')
-      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'before');
+      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'hook.destroy');
     if (promiseResolve !== undefined && typeof promiseResolve !== 'function')
-      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'promiseResolve');
+      throw new errors.TypeError('ERR_ASYNC_CALLBACK', 'hook.promiseResolve');
 
     this[init_symbol] = init;
     this[before_symbol] = before;
diff --git a/lib/internal/process.js b/lib/internal/process.js
index 4573b9429ed0cd..1d1ed5cd977f51 100644
--- a/lib/internal/process.js
+++ b/lib/internal/process.js
@@ -201,7 +201,7 @@ function setupSignalHandlers() {
 
       wrap.unref();
 
-      wrap.onsignal = function() { process.emit(type); };
+      wrap.onsignal = function() { process.emit(type, type); };
 
       const signum = constants[type];
       const err = wrap.start(signum);
diff --git a/lib/perf_hooks.js b/lib/perf_hooks.js
index 6fd6e4a6b768ce..bd1bee19fc2a54 100644
--- a/lib/perf_hooks.js
+++ b/lib/perf_hooks.js
@@ -8,6 +8,7 @@ const {
   observerCounts,
   setupObservers,
   timeOrigin,
+  timeOriginTimestamp,
   timerify,
   constants
 } = process.binding('performance');
@@ -145,6 +146,13 @@ function now() {
   return hr[0] * 1000 + hr[1] / 1e6;
 }
 
+function getMilestoneTimestamp(milestoneIdx) {
+  const ns = milestones[milestoneIdx];
+  if (ns === -1)
+    return ns;
+  return ns / 1e6 - timeOrigin;
+}
+
 class PerformanceNodeTiming {
   constructor() {}
 
@@ -157,7 +165,7 @@ class PerformanceNodeTiming {
   }
 
   get startTime() {
-    return timeOrigin;
+    return 0;
   }
 
   get duration() {
@@ -165,59 +173,64 @@ class PerformanceNodeTiming {
   }
 
   get nodeStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_NODE_START];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_NODE_START);
   }
 
   get v8Start() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_V8_START];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_V8_START);
   }
 
   get environment() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_ENVIRONMENT];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_ENVIRONMENT);
   }
 
   get loopStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_LOOP_START];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_START);
   }
 
   get loopExit() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_LOOP_EXIT];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_LOOP_EXIT);
   }
 
   get bootstrapComplete() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
   }
 
   get thirdPartyMainStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_THIRD_PARTY_MAIN_START];
+    return getMilestoneTimestamp(
+      NODE_PERFORMANCE_MILESTONE_THIRD_PARTY_MAIN_START);
   }
 
   get thirdPartyMainEnd() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_THIRD_PARTY_MAIN_END];
+    return getMilestoneTimestamp(
+      NODE_PERFORMANCE_MILESTONE_THIRD_PARTY_MAIN_END);
   }
 
   get clusterSetupStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_CLUSTER_SETUP_START];
+    return getMilestoneTimestamp(
+      NODE_PERFORMANCE_MILESTONE_CLUSTER_SETUP_START);
   }
 
   get clusterSetupEnd() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_CLUSTER_SETUP_END];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_CLUSTER_SETUP_END);
   }
 
   get moduleLoadStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_MODULE_LOAD_START];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_MODULE_LOAD_START);
   }
 
   get moduleLoadEnd() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_MODULE_LOAD_END];
+    return getMilestoneTimestamp(NODE_PERFORMANCE_MILESTONE_MODULE_LOAD_END);
   }
 
   get preloadModuleLoadStart() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_PRELOAD_MODULE_LOAD_START];
+    return getMilestoneTimestamp(
+      NODE_PERFORMANCE_MILESTONE_PRELOAD_MODULE_LOAD_START);
   }
 
   get preloadModuleLoadEnd() {
-    return milestones[NODE_PERFORMANCE_MILESTONE_PRELOAD_MODULE_LOAD_END];
+    return getMilestoneTimestamp(
+      NODE_PERFORMANCE_MILESTONE_PRELOAD_MODULE_LOAD_END);
   }
 
   [kInspect]() {
@@ -466,11 +479,11 @@ class Performance extends PerformanceObserverEntryList {
   }
 
   get timeOrigin() {
-    return timeOrigin;
+    return timeOriginTimestamp;
   }
 
   now() {
-    return now();
+    return now() - timeOrigin;
   }
 
   mark(name) {
@@ -549,8 +562,9 @@ class Performance extends PerformanceObserverEntryList {
 
   [kInspect]() {
     return {
-      timeOrigin,
-      nodeTiming
+      maxEntries: this.maxEntries,
+      nodeTiming: this.nodeTiming,
+      timeOrigin: this.timeOrigin
     };
   }
 }
diff --git a/lib/repl.js b/lib/repl.js
index bbadfea5b3d8d4..84d37bc3dd492b 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -1337,14 +1337,15 @@ function isRecoverableError(e, code) {
   if (e && e.name === 'SyntaxError') {
     var message = e.message;
     if (message === 'Unterminated template literal' ||
-        message === 'Missing } in template expression') {
+        message === 'Unexpected end of input') {
       return true;
     }
 
-    if (message.startsWith('Unexpected end of input') ||
-        message.startsWith('missing ) after argument list') ||
-        message.startsWith('Unexpected token'))
-      return true;
+    if (message === 'missing ) after argument list') {
+      const frames = e.stack.split(/\r?\n/);
+      const pos = frames.findIndex((f) => f.match(/^\s*\^+$/));
+      return pos > 0 && frames[pos - 1].length === frames[pos].length;
+    }
 
     if (message === 'Invalid or unexpected token')
       return isCodeRecoverable(code);
diff --git a/lib/v8.js b/lib/v8.js
index ba95c98dadc1ee..fccc39edc6833f 100644
--- a/lib/v8.js
+++ b/lib/v8.js
@@ -154,7 +154,7 @@ class DefaultSerializer extends Serializer {
       i = arrayBufferViewTypeToIndex.get(tag);
 
       if (i === undefined) {
-        throw this._getDataCloneError(`Unknown host object type: ${tag}`);
+        throw new this._getDataCloneError(`Unknown host object type: ${tag}`);
       }
     }
     this.writeUint32(i);
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 1be8d92654eae2..66ed992f9b0da5 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -3736,7 +3736,7 @@ bool CipherBase::Update(const char* data,
                         unsigned char** out,
                         int* out_len) {
   if (ctx_ == nullptr)
-    return 0;
+    return false;
 
   // on first update:
   if (kind_ == kDecipher && IsAuthenticatedMode() && auth_tag_len_ > 0) {
diff --git a/src/node_perf.cc b/src/node_perf.cc
index dd833552850ab4..c9344435297f6f 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -3,6 +3,10 @@
 
 #include <vector>
 
+#ifdef __POSIX__
+#include <sys/time.h>  // gettimeofday
+#endif
+
 namespace node {
 namespace performance {
 
@@ -22,13 +26,38 @@ using v8::Object;
 using v8::String;
 using v8::Value;
 
+// Microseconds in a second, as a float.
+#define MICROS_PER_SEC 1e6
+// Microseconds in a millisecond, as a float.
+#define MICROS_PER_MILLIS 1e3
+
+// https://w3c.github.io/hr-time/#dfn-time-origin
 const uint64_t timeOrigin = PERFORMANCE_NOW();
+// https://w3c.github.io/hr-time/#dfn-time-origin-timestamp
+const double timeOriginTimestamp = GetCurrentTimeInMicroseconds();
 uint64_t performance_node_start;
 uint64_t performance_v8_start;
 
 uint64_t performance_last_gc_start_mark_ = 0;
 v8::GCType performance_last_gc_type_ = v8::GCType::kGCTypeAll;
 
+double GetCurrentTimeInMicroseconds() {
+#ifdef _WIN32
+// The difference between the Unix Epoch and the Windows Epoch in 100-ns ticks.
+#define TICKS_TO_UNIX_EPOCH 116444736000000000LL
+  FILETIME ft;
+  GetSystemTimeAsFileTime(&ft);
+  uint64_t filetime_int = static_cast<uint64_t>(ft.dwHighDateTime) << 32 |
+                          ft.dwLowDateTime;
+  // FILETIME is measured in terms of 100 ns. Convert that to 1 us (1000 ns).
+  return (filetime_int - TICKS_TO_UNIX_EPOCH) / 10.;
+#else
+  struct timeval tp;
+  gettimeofday(&tp, nullptr);
+  return MICROS_PER_SEC * tp.tv_sec + tp.tv_usec;
+#endif
+}
+
 // Initialize the performance entry object properties
 inline void InitObject(const PerformanceEntry& entry, Local<Object> obj) {
   Environment* env = entry.env();
@@ -382,6 +411,12 @@ void Init(Local<Object> target,
                             v8::Number::New(isolate, timeOrigin / 1e6),
                             attr).ToChecked();
 
+  target->DefineOwnProperty(
+      context,
+      FIXED_ONE_BYTE_STRING(isolate, "timeOriginTimestamp"),
+      v8::Number::New(isolate, timeOriginTimestamp / MICROS_PER_MILLIS),
+      attr).ToChecked();
+
   target->DefineOwnProperty(context,
                             env->constants_string(),
                             constants,
diff --git a/src/node_perf.h b/src/node_perf.h
index 6091c0752cd493..f709479d0ddfb5 100644
--- a/src/node_perf.h
+++ b/src/node_perf.h
@@ -22,6 +22,10 @@ using v8::Local;
 using v8::Object;
 using v8::Value;
 
+extern const uint64_t timeOrigin;
+
+double GetCurrentTimeInMicroseconds();
+
 static inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
 #define V(name, label)                                                        \
   if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
@@ -77,11 +81,11 @@ class PerformanceEntry {
     return ToPerformanceEntryTypeEnum(type().c_str());
   }
 
-  double startTime() const { return startTime_ / 1e6; }
+  double startTime() const { return startTimeNano() / 1e6; }
 
   double duration() const { return durationNano() / 1e6; }
 
-  uint64_t startTimeNano() const { return startTime_; }
+  uint64_t startTimeNano() const { return startTime_ - timeOrigin; }
 
   uint64_t durationNano() const { return endTime_ - startTime_; }
 
diff --git a/src/node_perf_common.h b/src/node_perf_common.h
index 435a4cffe5a753..7ff57359ba5cb8 100644
--- a/src/node_perf_common.h
+++ b/src/node_perf_common.h
@@ -4,6 +4,7 @@
 #include "node.h"
 #include "v8.h"
 
+#include <algorithm>
 #include <map>
 #include <string>
 
@@ -76,7 +77,10 @@ class performance_state {
       isolate,
       offsetof(performance_state_internal, observers),
       NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
-      root) {}
+      root) {
+    for (size_t i = 0; i < milestones.Length(); i++)
+      milestones[i] = -1.;
+  }
 
   AliasedBuffer<uint8_t, v8::Uint8Array> root;
   AliasedBuffer<double, v8::Float64Array> milestones;
diff --git a/test/abort/test-abort-backtrace.js b/test/abort/test-abort-backtrace.js
index e69ac3ddfdece8..7f87ef0e7f4559 100644
--- a/test/abort/test-abort-backtrace.js
+++ b/test/abort/test-abort-backtrace.js
@@ -19,7 +19,8 @@ if (process.argv[2] === 'child') {
     }
 
     if (!common.isWindows) {
-      if (!frames.some((frame) => frame.includes(`[${process.execPath}]`))) {
+      const { getBinaryPath } = require('../common/shared-lib-util');
+      if (!frames.some((frame) => frame.includes(`[${getBinaryPath()}]`))) {
         assert.fail(`Some frames should include the binary name:\n${stderr}`);
       }
     }
diff --git a/test/addons/symlinked-module/test.js b/test/addons/symlinked-module/test.js
index 53306399cb520b..e8c26544f2a38c 100644
--- a/test/addons/symlinked-module/test.js
+++ b/test/addons/symlinked-module/test.js
@@ -19,7 +19,7 @@ const addonPath = path.join(__dirname, 'build', common.buildType);
 const addonLink = path.join(tmpdir.path, 'addon');
 
 try {
-  fs.symlinkSync(addonPath, addonLink);
+  fs.symlinkSync(addonPath, addonLink, 'dir');
 } catch (err) {
   if (err.code !== 'EPERM') throw err;
   common.skip('module identity test (no privs for symlinks)');
diff --git a/test/common/shared-lib-util.js b/test/common/shared-lib-util.js
index 963c6ee1391d8e..36c518a2f03c94 100644
--- a/test/common/shared-lib-util.js
+++ b/test/common/shared-lib-util.js
@@ -28,7 +28,7 @@ exports.addLibraryPath = function(env) {
     path.dirname(process.execPath);
 };
 
-// Get the full path of shared lib
+// Get the full path of shared lib.
 exports.getSharedLibPath = function() {
   if (common.isWindows) {
     return path.join(path.dirname(process.execPath), 'node.dll');
@@ -41,3 +41,9 @@ exports.getSharedLibPath = function() {
                      `libnode.${process.config.variables.shlib_suffix}`);
   }
 };
+
+// Get the binary path of stack frames.
+exports.getBinaryPath = function() {
+  return process.config.variables.node_shared ?
+    exports.getSharedLibPath() : process.execPath;
+};
diff --git a/test/es-module/test-esm-symlink.js b/test/es-module/test-esm-symlink.js
index 074230ac06c4b5..232925a52e3f64 100644
--- a/test/es-module/test-esm-symlink.js
+++ b/test/es-module/test-esm-symlink.js
@@ -37,7 +37,7 @@ try {
   fs.symlinkSync(real, link_absolute_path);
   fs.symlinkSync(path.basename(real), link_relative_path);
   fs.symlinkSync(real, link_ignore_extension);
-  fs.symlinkSync(path.dirname(real), link_directory);
+  fs.symlinkSync(path.dirname(real), link_directory, 'dir');
 } catch (err) {
   if (err.code !== 'EPERM') throw err;
   common.skip('insufficient privileges for symlinks');
diff --git a/test/internet/test-http-https-default-ports.js b/test/internet/test-http-https-default-ports.js
index 5f1b9eddb4f416..ddf4c5d73902bc 100644
--- a/test/internet/test-http-https-default-ports.js
+++ b/test/internet/test-http-https-default-ports.js
@@ -30,10 +30,10 @@ const https = require('https');
 
 const http = require('http');
 
-https.get(`https://${addresses.INET_HOST}/`, common.mustCall(function(res) {
+https.get(`https://${addresses.INET_HOST}/`, common.mustCall((res) => {
   res.resume();
 }));
 
-http.get(`http://${addresses.INET_HOST}/`, common.mustCall(function(res) {
+http.get(`http://${addresses.INET_HOST}/`, common.mustCall((res) => {
   res.resume();
 }));
diff --git a/test/parallel/test-async-hooks-constructor.js b/test/parallel/test-async-hooks-constructor.js
new file mode 100644
index 00000000000000..f2b4df6a9f9f99
--- /dev/null
+++ b/test/parallel/test-async-hooks-constructor.js
@@ -0,0 +1,23 @@
+'use strict';
+
+// This tests that AsyncHooks throws an error if bad parameters are passed.
+
+const common = require('../common');
+const async_hooks = require('async_hooks');
+const non_function = 10;
+
+typeErrorForFunction('init');
+typeErrorForFunction('before');
+typeErrorForFunction('after');
+typeErrorForFunction('destroy');
+typeErrorForFunction('promiseResolve');
+
+function typeErrorForFunction(functionName) {
+  common.expectsError(() => {
+    async_hooks.createHook({ [functionName]: non_function });
+  }, {
+    code: 'ERR_ASYNC_CALLBACK',
+    type: TypeError,
+    message: `hook.${functionName} must be a function`
+  });
+}
diff --git a/test/parallel/test-crypto-hash.js b/test/parallel/test-crypto-hash.js
index ef540681e2a46b..847b3394122f50 100644
--- a/test/parallel/test-crypto-hash.js
+++ b/test/parallel/test-crypto-hash.js
@@ -82,15 +82,15 @@ assert.deepStrictEqual(
 );
 
 // stream interface should produce the same result.
-assert.deepStrictEqual(a5, a3, 'stream interface is consistent');
-assert.deepStrictEqual(a6, a3, 'stream interface is consistent');
-assert.notStrictEqual(a7, undefined, 'no data should return data');
-assert.notStrictEqual(a8, undefined, 'empty string should generate data');
+assert.deepStrictEqual(a5, a3);
+assert.deepStrictEqual(a6, a3);
+assert.notStrictEqual(a7, undefined);
+assert.notStrictEqual(a8, undefined);
 
 // Test multiple updates to same hash
 const h1 = crypto.createHash('sha1').update('Test123').digest('hex');
 const h2 = crypto.createHash('sha1').update('Test').update('123').digest('hex');
-assert.strictEqual(h1, h2, 'multipled updates');
+assert.strictEqual(h1, h2);
 
 // Test hashing for binary files
 const fn = fixtures.path('sample.png');
diff --git a/test/parallel/test-crypto-hmac.js b/test/parallel/test-crypto-hmac.js
index 9f04b19cf3eddc..5fb45913b2fd9f 100644
--- a/test/parallel/test-crypto-hmac.js
+++ b/test/parallel/test-crypto-hmac.js
@@ -253,7 +253,12 @@ for (let i = 0, l = rfc4231.length; i < l; i++) {
       expected,
       `Test HMAC-${hash} rfc 4231 case ${i + 1}: ${actual} must be ${expected}`
     );
-    assert.strictEqual(actual, strRes, 'Should get same result from stream');
+    assert.strictEqual(
+      actual,
+      strRes,
+      `Should get same result from stream (hash: ${hash} and case: ${i + 1})` +
+      ` => ${actual} must be ${strRes}`
+    );
   }
 }
 
diff --git a/test/parallel/test-http-client-spurious-aborted.js b/test/parallel/test-http-client-spurious-aborted.js
new file mode 100644
index 00000000000000..58a2f92de94054
--- /dev/null
+++ b/test/parallel/test-http-client-spurious-aborted.js
@@ -0,0 +1,75 @@
+'use strict';
+
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+const { Writable } = require('stream');
+const Countdown = require('../common/countdown');
+
+const N = 2;
+let abortRequest = true;
+
+const server = http.Server(common.mustCall((req, res) => {
+  const headers = { 'Content-Type': 'text/plain' };
+  headers['Content-Length'] = 50;
+  const socket = res.socket;
+  res.writeHead(200, headers);
+  res.write('aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd');
+  if (abortRequest) {
+    process.nextTick(() => socket.destroy());
+  } else {
+    process.nextTick(() => res.end('eeeeeeeeee'));
+  }
+}, N));
+
+server.listen(0, common.mustCall(() => {
+  download();
+}));
+
+const finishCountdown = new Countdown(N, common.mustCall(() => {
+  server.close();
+}));
+const reqCountdown = new Countdown(N, common.mustCall());
+
+function download() {
+  const opts = {
+    port: server.address().port,
+    path: '/',
+  };
+  const req = http.get(opts);
+  req.on('error', common.mustNotCall());
+  req.on('response', (res) => {
+    assert.strictEqual(res.statusCode, 200);
+    assert.strictEqual(res.headers.connection, 'close');
+    let aborted = false;
+    const writable = new Writable({
+      write(chunk, encoding, callback) {
+        callback();
+      }
+    });
+    res.pipe(writable);
+    const _handle = res.socket._handle;
+    _handle._close = res.socket._handle.close;
+    _handle.close = function(callback) {
+      _handle._close();
+      // set readable to true even though request is complete
+      if (res.complete) res.readable = true;
+      callback();
+    };
+    res.on('end', common.mustCall(() => {
+      reqCountdown.dec();
+    }));
+    res.on('aborted', () => {
+      aborted = true;
+    });
+    res.on('error', common.mustNotCall());
+    writable.on('finish', () => {
+      assert.strictEqual(aborted, abortRequest);
+      finishCountdown.dec();
+      if (finishCountdown.remaining === 0) return;
+      abortRequest = false; // next one should be a good response
+      download();
+    });
+  });
+  req.end();
+}
diff --git a/test/parallel/test-http2-client-write-empty-string.js b/test/parallel/test-http2-client-write-empty-string.js
index c10698d417038d..8b8cb3d6404e1e 100644
--- a/test/parallel/test-http2-client-write-empty-string.js
+++ b/test/parallel/test-http2-client-write-empty-string.js
@@ -1,12 +1,13 @@
 'use strict';
 
 const assert = require('assert');
-const http2 = require('http2');
 
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+const http2 = require('http2');
+
 for (const chunkSequence of [
   [ '' ],
   [ '', '' ]
diff --git a/test/parallel/test-module-symlinked-peer-modules.js b/test/parallel/test-module-symlinked-peer-modules.js
index f93dea720f9a12..27e67b31d182e5 100644
--- a/test/parallel/test-module-symlinked-peer-modules.js
+++ b/test/parallel/test-module-symlinked-peer-modules.js
@@ -43,7 +43,7 @@ fs.mkdirSync(moduleB);
 // Attempt to make the symlink. If this fails due to lack of sufficient
 // permissions, the test will bail out and be skipped.
 try {
-  fs.symlinkSync(moduleA, moduleA_link);
+  fs.symlinkSync(moduleA, moduleA_link, 'dir');
 } catch (err) {
   if (err.code !== 'EPERM') throw err;
   common.skip('insufficient privileges for symlinks');
diff --git a/test/parallel/test-postmortem-metadata.js b/test/parallel/test-postmortem-metadata.js
index 75cc7bdda33cef..1860028333e032 100644
--- a/test/parallel/test-postmortem-metadata.js
+++ b/test/parallel/test-postmortem-metadata.js
@@ -23,6 +23,11 @@ const nm = spawnSync('nm', args);
 if (nm.error && nm.error.errno === 'ENOENT')
   common.skip('nm not found on system');
 
+const stderr = nm.stderr.toString();
+if (stderr.length > 0) {
+  common.skip(`Failed to execute nm: ${stderr}`);
+}
+
 const symbolRe = /\s_?(v8dbg_.+)$/;
 const symbols = nm.stdout.toString().split('\n').reduce((filtered, line) => {
   const match = line.match(symbolRe);
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index 9d660607991c24..12685c91caaefa 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -165,13 +165,23 @@ const errorTests = [
     send: '.break',
     expect: ''
   },
-  // Template expressions can cross lines
+  // Template expressions
   {
     send: '`io.js ${"1.0"',
+    expect: [
+      kSource,
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
+  },
+  {
+    send: '`io.js ${',
     expect: '... '
   },
   {
-    send: '+ ".2"}`',
+    send: '"1.0" + ".2"}`',
     expect: '\'io.js 1.0.2\''
   },
   // Dot prefix in multiline commands aren't treated as commands
@@ -636,14 +646,68 @@ const errorTests = [
   },
   // Do not parse `...[]` as a REPL keyword
   {
-    send: '...[]\n',
-    expect: '... ... '
+    send: '...[]',
+    expect: [
+      kSource,
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
   },
   // bring back the repl to prompt
   {
     send: '.break',
     expect: ''
-  }
+  },
+  {
+    send: 'console.log("Missing comma in arg list" process.version)',
+    expect: [
+      kSource,
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
+  },
+  {
+    send: 'x = {\nfield\n{',
+    expect: [
+      '... ... {',
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
+  },
+  {
+    send: '(2 + 3))',
+    expect: [
+      kSource,
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
+  },
+  {
+    send: 'if (typeof process === "object"); {',
+    expect: '... '
+  },
+  {
+    send: 'console.log("process is defined");',
+    expect: '... '
+  },
+  {
+    send: '} else {',
+    expect: [
+      kSource,
+      kArrow,
+      '',
+      /^SyntaxError: /,
+      ''
+    ]
+  },
 ];
 
 const tcpTests = [
diff --git a/test/parallel/test-signal-args.js b/test/parallel/test-signal-args.js
new file mode 100644
index 00000000000000..d9fa6df347ddaa
--- /dev/null
+++ b/test/parallel/test-signal-args.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (common.isWindows) {
+  common.skip('Sending signals with process.kill is not supported on Windows');
+}
+
+process.once('SIGINT', common.mustCall((signal) => {
+  assert.strictEqual(signal, 'SIGINT');
+}));
+
+process.kill(process.pid, 'SIGINT');
+
+process.once('SIGTERM', common.mustCall((signal) => {
+  assert.strictEqual(signal, 'SIGTERM');
+}));
+
+process.kill(process.pid, 'SIGTERM');
+
+// Prevent Node.js from exiting due to empty event loop before signal handlers
+// are fired
+setImmediate(() => {});
diff --git a/test/parallel/test-tls-wrap-event-emmiter.js b/test/parallel/test-tls-wrap-event-emmiter.js
index b6ae9e2d5a7e99..871e6c9ae6834c 100644
--- a/test/parallel/test-tls-wrap-event-emmiter.js
+++ b/test/parallel/test-tls-wrap-event-emmiter.js
@@ -15,5 +15,5 @@ const TlsSocket = require('tls').TLSSocket;
 const EventEmitter = require('events').EventEmitter;
 assert.throws(
   () => { new TlsSocket(new EventEmitter()); },
-  /^TypeError: (.+) is not a function$/
+  TypeError
 );
diff --git a/test/parallel/test-performance.js b/test/sequential/test-performance.js
similarity index 56%
rename from test/parallel/test-performance.js
rename to test/sequential/test-performance.js
index 23ae4370c3cd7a..06fc0912e446c3 100644
--- a/test/parallel/test-performance.js
+++ b/test/sequential/test-performance.js
@@ -7,6 +7,12 @@ const { performance } = require('perf_hooks');
 assert(performance);
 assert(performance.nodeTiming);
 assert.strictEqual(typeof performance.timeOrigin, 'number');
+// Use a fairly large epsilon value, since we can only guarantee that the node
+// process started up in 20 seconds.
+assert(Math.abs(performance.timeOrigin - Date.now()) < 20000);
+
+const inited = performance.now();
+assert(inited < 20000);
 
 {
   const entries = performance.getEntries();
@@ -103,23 +109,81 @@ assert.strictEqual(typeof performance.timeOrigin, 'number');
 assert.strictEqual(performance.nodeTiming.name, 'node');
 assert.strictEqual(performance.nodeTiming.entryType, 'node');
 
-[
-  'startTime',
-  'duration',
-  'nodeStart',
-  'v8Start',
-  'bootstrapComplete',
-  'environment',
-  'loopStart',
-  'loopExit',
-  'thirdPartyMainStart',
-  'thirdPartyMainEnd',
-  'clusterSetupStart',
-  'clusterSetupEnd',
-  'moduleLoadStart',
-  'moduleLoadEnd',
-  'preloadModuleLoadStart',
-  'preloadModuleLoadEnd'
-].forEach((i) => {
-  assert.strictEqual(typeof performance.nodeTiming[i], 'number');
+function checkNodeTiming(props) {
+  for (const prop of Object.keys(props)) {
+    if (props[prop].around !== undefined) {
+      assert.strictEqual(typeof performance.nodeTiming[prop], 'number');
+      const delta = performance.nodeTiming[prop] - props[prop].around;
+      assert(Math.abs(delta) < 1000);
+    } else {
+      assert.strictEqual(performance.nodeTiming[prop], props[prop]);
+    }
+  }
+}
+
+checkNodeTiming({
+  name: 'node',
+  entryType: 'node',
+  startTime: 0,
+  duration: { around: performance.now() },
+  nodeStart: { around: 0 },
+  v8Start: { around: 0 },
+  bootstrapComplete: -1,
+  environment: { around: 0 },
+  loopStart: -1,
+  loopExit: -1,
+  thirdPartyMainStart: -1,
+  thirdPartyMainEnd: -1,
+  clusterSetupStart: -1,
+  clusterSetupEnd: -1,
+  moduleLoadStart: { around: inited },
+  moduleLoadEnd: { around: inited },
+  preloadModuleLoadStart: { around: inited },
+  preloadModuleLoadEnd: { around: inited },
+});
+
+setTimeout(() => {
+  checkNodeTiming({
+    name: 'node',
+    entryType: 'node',
+    startTime: 0,
+    duration: { around: performance.now() },
+    nodeStart: { around: 0 },
+    v8Start: { around: 0 },
+    bootstrapComplete: { around: inited },
+    environment: { around: 0 },
+    loopStart: { around: inited },
+    loopExit: -1,
+    thirdPartyMainStart: -1,
+    thirdPartyMainEnd: -1,
+    clusterSetupStart: -1,
+    clusterSetupEnd: -1,
+    moduleLoadStart: { around: inited },
+    moduleLoadEnd: { around: inited },
+    preloadModuleLoadStart: { around: inited },
+    preloadModuleLoadEnd: { around: inited },
+  });
+}, 2000);
+
+process.on('exit', () => {
+  checkNodeTiming({
+    name: 'node',
+    entryType: 'node',
+    startTime: 0,
+    duration: { around: performance.now() },
+    nodeStart: { around: 0 },
+    v8Start: { around: 0 },
+    bootstrapComplete: { around: inited },
+    environment: { around: 0 },
+    loopStart: { around: inited },
+    loopExit: { around: performance.now() },
+    thirdPartyMainStart: -1,
+    thirdPartyMainEnd: -1,
+    clusterSetupStart: -1,
+    clusterSetupEnd: -1,
+    moduleLoadStart: { around: inited },
+    moduleLoadEnd: { around: inited },
+    preloadModuleLoadStart: { around: inited },
+    preloadModuleLoadEnd: { around: inited },
+  });
 });
diff --git a/tools/icu/iculslocs.cc b/tools/icu/iculslocs.cc
index 3ceb8d2a4d81d0..a6931d3a9a62d6 100644
--- a/tools/icu/iculslocs.cc
+++ b/tools/icu/iculslocs.cc
@@ -55,6 +55,7 @@ Japanese, it doesn't *claim* to have Japanese.
 #include <unicode/ures.h>
 #include <unicode/udata.h>
 #include <unicode/putil.h>
+#include <stdio.h>
 
 const char* PROG = "iculslocs";
 const char* NAME = U_ICUDATA_NAME;  // assume ICU data