diff --git a/doc/api/test.md b/doc/api/test.md
index 573f2da98f9d..25f354dae45e 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -1365,6 +1365,63 @@ test('runs timers as setTime passes ticks', (context) => {
 });
 ```
 
+### Temporal
+
+The mock timers API also allows mocking the [`Temporal.Now`][] methods that
+read the current time. This is useful for testing code that reads the current
+time through the Temporal API instead of the legacy `Date` object.
+
+Enabling the `'Temporal.Now'` api mocks the following methods:
+
+* `Temporal.Now.instant()`
+* `Temporal.Now.zonedDateTimeISO()`
+* `Temporal.Now.plainDateTimeISO()`
+* `Temporal.Now.plainDateISO()`
+* `Temporal.Now.plainTimeISO()`
+
+`Temporal.Now.timeZoneId()` is not mocked and keeps returning the actual
+system time zone. Only the clock is virtualized, not the time zone.
+
+**Note:** `Date` and `Temporal.Now` share the same internal mock clock. When
+both are mocked, `Date.now()` and `Temporal.Now.instant().epochMilliseconds`
+always agree, and advancing the clock with `.tick()` or `.setTime()` advances
+both.
+
+**Note:** The mock clock has millisecond precision, while `Temporal.Instant`
+has nanosecond precision. Mocked values are derived from the clock's
+millisecond value, so the sub-millisecond digits of
+`Temporal.Now.instant().epochNanoseconds` are always zero.
+
+```mjs
+import assert from 'node:assert';
+import { test } from 'node:test';
+
+test('mocks Temporal.Now', (context) => {
+  // Optionally choose what to mock
+  context.mock.timers.enable({ apis: ['Temporal.Now'], now: 9999 });
+  assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 9999);
+
+  // Advance in time will also advance Temporal.Now
+  context.mock.timers.tick(1);
+  assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 10000);
+});
+```
+
+```cjs
+const assert = require('node:assert');
+const { test } = require('node:test');
+
+test('mocks Temporal.Now', (context) => {
+  // Optionally choose what to mock
+  context.mock.timers.enable({ apis: ['Temporal.Now'], now: 9999 });
+  assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 9999);
+
+  // Advance in time will also advance Temporal.Now
+  context.mock.timers.tick(1);
+  assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 10000);
+});
+```
+
 ## Snapshot testing
 
 <!-- YAML
@@ -2914,7 +2971,8 @@ Mocking timers is a technique commonly used in software testing to simulate and
 control the behavior of timers, such as `setInterval` and `setTimeout`,
 without actually waiting for the specified time intervals.
 
-MockTimers is also able to mock the `Date` object.
+MockTimers is also able to mock the `Date` object and the [`Temporal.Now`][]
+methods.
 
 The [`MockTracker`][] provides a top-level `timers` export
 which is a `MockTimers` instance.
@@ -2926,6 +2984,9 @@ added:
   - v20.4.0
   - v18.19.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Added support for mocking `Temporal.Now`.
   - version:
     - v21.2.0
     - v20.11.0
@@ -2940,19 +3001,25 @@ Enables timer mocking for the specified timers.
   mocking. The following properties are supported:
   * `apis` {Array} An optional array containing the timers to mock.
     The currently supported timer values are `'setInterval'`, `'setTimeout'`, `'setImmediate'`,
-    and `'Date'`. **Default:** `['setInterval', 'setTimeout', 'setImmediate', 'Date']`.
+    `'Date'`, and `'Temporal.Now'`.
+    **Default:** `['setInterval', 'setTimeout', 'setImmediate', 'Date', 'Temporal.Now']`.
     If no array is provided, all time related APIs (`'setInterval'`, `'clearInterval'`,
-    `'setTimeout'`, `'clearTimeout'`, `'setImmediate'`, `'clearImmediate'`, and
-    `'Date'`) will be mocked by default.
+    `'setTimeout'`, `'clearTimeout'`, `'setImmediate'`, `'clearImmediate'`,
+    `'Date'`, and `'Temporal.Now'`) will be mocked by default.
   * `now` {number | Date} An optional number or Date object representing the
     initial time (in milliseconds) to use as the value
-    for `Date.now()`. **Default:** `0`.
+    for `Date.now()` and the mocked [`Temporal.Now`][] methods. **Default:** `0`.
 
 **Note:** When you enable mocking for a specific timer, its associated
 clear function will also be implicitly mocked.
 
-**Note:** Mocking `Date` will affect the behavior of the mocked timers
-as they use the same internal clock.
+**Note:** Mocking `Date` or `Temporal.Now` will affect the behavior of the
+mocked timers as they use the same internal clock.
+
+**Note:** Mocking `Temporal.Now` only virtualizes the clock.
+`Temporal.Now.timeZoneId()` is not mocked and returns the actual system time
+zone. Since the internal clock has millisecond precision, the sub-millisecond
+digits of `Temporal.Now.instant().epochNanoseconds` are always zero.
 
 Example usage without setting initial time:
 
@@ -3002,7 +3069,8 @@ All timers (`'setInterval'`, `'clearInterval'`, `'setTimeout'`, `'clearTimeout'`
 `'setImmediate'`, and `'clearImmediate'`) will be mocked. The `setInterval`,
 `clearInterval`, `setTimeout`, `clearTimeout`, `setImmediate`, and
 `clearImmediate` functions from `node:timers`, `node:timers/promises`, and
-`globalThis` will be mocked. As well as the global `Date` object.
+`globalThis` will be mocked. As well as the global `Date` object and the
+[`Temporal.Now`][] methods.
 
 ### `timers.reset()`
 
@@ -4957,6 +5025,7 @@ test.describe('my suite', (suite) => {
 [`MockTracker`]: #class-mocktracker
 [`NODE_V8_COVERAGE`]: cli.md#node_v8_coveragedir
 [`SuiteContext`]: #class-suitecontext
+[`Temporal.Now`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Now
 [`TestContext`]: #class-testcontext
 [`TracingChannel`]: diagnostics_channel.md#class-tracingchannel
 [`assert.throws`]: assert.md#assertthrowsfn-error-message
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 9d5891e7a24a..89418becd94d 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -140,6 +140,8 @@ function prepareExecution(options) {
 
   require('internal/dns/utils').initializeDns();
 
+  require('internal/util/temporal').initialize();
+
   if (isMainThread) {
     assert(internalBinding('worker').isMainThread);
     // Worker threads will get the manifest in the message handler.
diff --git a/lib/internal/test_runner/mock/mock_timers.js b/lib/internal/test_runner/mock/mock_timers.js
index 1e425b606ee5..845eec51a936 100644
--- a/lib/internal/test_runner/mock/mock_timers.js
+++ b/lib/internal/test_runner/mock/mock_timers.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayPrototypeFilter,
   ArrayPrototypeForEach,
   ArrayPrototypeIncludes,
   DatePrototypeGetTime,
@@ -40,6 +41,11 @@ const { AbortController, AbortSignal } = require('internal/abort_controller');
 
 const { TIMEOUT_MAX } = require('internal/timers');
 
+// internal/util/temporal is initialized in the pre-execution phase, so its
+// properties must be accessed at the point of use rather than destructured
+// at module load time.
+const temporalUtils = require('internal/util/temporal');
+
 const PriorityQueue = require('internal/priority_queue');
 const nodeTimers = require('timers');
 const nodeTimersPromises = require('timers/promises');
@@ -63,7 +69,8 @@ function abortIt(signal) {
 }
 
 /**
- * @typedef {('setTimeout'|'setInterval'|'setImmediate'|'Date'|'scheduler.wait'|'AbortSignal.timeout')[]} SupportedApis
+ * @typedef {('setTimeout'|'setInterval'|'setImmediate'|'Date'|
+ *   'scheduler.wait'|'AbortSignal.timeout'|'Temporal.Now')[]} SupportedApis
  * Supported timers that can be enabled via MockTimers.enable({ apis: [...] })
  */
 const SUPPORTED_APIS = [
@@ -73,6 +80,17 @@ const SUPPORTED_APIS = [
   'Date',
   'scheduler.wait',
   'AbortSignal.timeout',
+  'Temporal.Now',
+];
+
+// Temporal.Now methods that read the current time. timeZoneId() is
+// intentionally not mocked: only the clock is virtualized, not the time zone.
+const MOCKED_TEMPORAL_NOW_METHODS = [
+  'instant',
+  'zonedDateTimeISO',
+  'plainDateTimeISO',
+  'plainDateISO',
+  'plainTimeISO',
 ];
 const TIMERS_DEFAULT_INTERVAL = {
   __proto__: null,
@@ -138,6 +156,7 @@ class MockTimers {
   #realPromisifiedSetImmediate;
 
   #nativeDateDescriptor;
+  #realTemporalNowDescriptors;
   #realAbortSignalTimeout;
 
   #timersInContext = [];
@@ -455,6 +474,51 @@ class MockTimers {
     return MockDate;
   }
 
+  #createTemporalNowMethods() {
+    const mock = this;
+    // The default time zone is read through the original timeZoneId captured
+    // at enable time, so it always matches what the non-mocked timeZoneId()
+    // returns.
+    const realTimeZoneId = this.#realTemporalNowDescriptors.timeZoneId.value;
+
+    function instant() {
+      return temporalUtils.TemporalInstantFromEpochMilliseconds(mock.#now);
+    }
+
+    function zonedDateTimeISO(timeZone = realTimeZoneId()) {
+      return temporalUtils.TemporalInstantPrototypeToZonedDateTimeISO(
+        instant(), timeZone,
+      );
+    }
+
+    function plainDateTimeISO(timeZone = realTimeZoneId()) {
+      return temporalUtils.TemporalZonedDateTimePrototypeToPlainDateTime(
+        zonedDateTimeISO(timeZone),
+      );
+    }
+
+    function plainDateISO(timeZone = realTimeZoneId()) {
+      return temporalUtils.TemporalZonedDateTimePrototypeToPlainDate(
+        zonedDateTimeISO(timeZone),
+      );
+    }
+
+    function plainTimeISO(timeZone = realTimeZoneId()) {
+      return temporalUtils.TemporalZonedDateTimePrototypeToPlainTime(
+        zonedDateTimeISO(timeZone),
+      );
+    }
+
+    return {
+      __proto__: null,
+      instant,
+      zonedDateTimeISO,
+      plainDateTimeISO,
+      plainDateISO,
+      plainTimeISO,
+    };
+  }
+
   async * #setIntervalPromisified(interval, result, options) {
     const emitter = new EventEmitter();
 
@@ -637,6 +701,22 @@ class MockTimers {
           this.#nativeDateDescriptor = ObjectSetPrototypeOf(ObjectGetOwnPropertyDescriptor(globalThis, 'Date'), null);
           globalThis.Date = this.#createDate();
         },
+        'Temporal.Now': () => {
+          const TemporalNow = globalThis.Temporal.Now;
+          this.#realTemporalNowDescriptors = ObjectSetPrototypeOf(
+            ObjectGetOwnPropertyDescriptors(TemporalNow), null);
+
+          const mocked = this.#createTemporalNowMethods();
+          ArrayPrototypeForEach(MOCKED_TEMPORAL_NOW_METHODS, (name) => {
+            ObjectDefineProperty(TemporalNow, name, {
+              __proto__: null,
+              configurable: true,
+              enumerable: true,
+              writable: true,
+              value: mocked[name],
+            });
+          });
+        },
         'AbortSignal.timeout': () => {
           this.#storeOriginalAbortSignalTimeout();
           const mock = this;
@@ -676,6 +756,15 @@ class MockTimers {
         'Date': () => {
           ObjectDefineProperty(globalThis, 'Date', this.#nativeDateDescriptor);
         },
+        'Temporal.Now': () => {
+          const TemporalNow = globalThis.Temporal.Now;
+          ArrayPrototypeForEach(MOCKED_TEMPORAL_NOW_METHODS, (name) => {
+            ObjectDefineProperty(
+              TemporalNow, name,
+              this.#realTemporalNowDescriptors[name],
+            );
+          });
+        },
         'AbortSignal.timeout': () => {
           this.#restoreOriginalAbortSignalTimeout();
         },
@@ -755,6 +844,24 @@ class MockTimers {
         );
       }
     });
+
+    if (!temporalUtils.hasTemporal || globalThis.Temporal === undefined) {
+      // When apis defaults to SUPPORTED_APIS, silently exclude the token so
+      // that a parameterless enable() keeps working on builds without
+      // Temporal. An explicit request is an error.
+      if (internalOptions.apis !== SUPPORTED_APIS &&
+          ArrayPrototypeIncludes(internalOptions.apis, 'Temporal.Now')) {
+        throw new ERR_INVALID_ARG_VALUE(
+          'options.apis',
+          'Temporal.Now',
+          'Temporal is not available in this environment',
+        );
+      }
+      internalOptions.apis = ArrayPrototypeFilter(
+        internalOptions.apis, (api) => api !== 'Temporal.Now',
+      );
+    }
+
     this.#timersInContext = internalOptions.apis;
 
     // Checks if the second argument is the initial time
diff --git a/lib/internal/util/temporal.js b/lib/internal/util/temporal.js
new file mode 100644
index 000000000000..559de6226288
--- /dev/null
+++ b/lib/internal/util/temporal.js
@@ -0,0 +1,116 @@
+'use strict';
+
+// This module is initialized in the pre-execution phase, before user code is
+// run. Since the module namespace is not populated at snapshot time, this
+// module should be not be imported with a destructuring pattern in a module
+// header or used within top-level module code, as the properties may not yet
+// be initialized. Either import this module lazily, or import the namespace
+// object without destructuring and access its properties at the point of use.
+
+// This module exposes the following exports:
+// * `hasTemporal`, a boolean property indicating whether the Temporal builtin
+//   is present during initialization.
+// * Typecheck methods for Temporal objects: `isTemporalDuration()`,
+//   `isTemporalInstant()` etc. If `hasTemporal` is false, then these methods
+//   will always return `false`. Note that these are much less performant than
+//   the native typecheck methods in internal/util/types, and should not be
+//   used in performance-critical paths.
+// If `hasTemporal` is true, then this module also exports the following, in
+// primordial style:
+// * Temporal constructors: `TemporalDuration`, `TemporalInstant` etc.
+// * Static methods on temporal constructors: `TemporalDurationCompare`,
+//   `TemporalDurationFrom` etc.
+// * Temporal prototype properties, methods and getters:
+//   `TemporalDurationPrototypeAbs`, `TemporalDurationPrototypeGetBlank` etc.
+
+// TODO(Renegade334): Remove typecheck methods once available via V8 API.
+// Replace with primordials if/when temporal_rs becomes a mandatory V8
+// build dependency and the harmony_temporal flag is removed.
+
+const {
+  ArrayPrototypeForEach,
+  FunctionPrototypeCall,
+  ObjectEntries,
+  ObjectGetOwnPropertyDescriptors,
+  SafeMap,
+  StringPrototypeSubstring,
+  StringPrototypeToUpperCase,
+  globalThis,
+  uncurryThis,
+} = primordials;
+
+// The keys of this Map are the Temporal constructor names.
+// The values are the names of the most lightweight brand-aware getter within
+// each prototype, which can be called speculatively as a brand check.
+const constructors = new SafeMap()
+    .set('Duration', 'nanoseconds')
+    .set('Instant', 'epochNanoseconds')
+    .set('PlainDate', 'calendarId')
+    .set('PlainDateTime', 'calendarId')
+    .set('PlainMonthDay', 'calendarId')
+    .set('PlainTime', 'nanosecond')
+    .set('PlainYearMonth', 'calendarId')
+    .set('ZonedDateTime', 'calendarId');
+
+exports.initialize = () => {
+  const { Temporal } = globalThis;
+
+  if (Temporal === undefined) {
+    exports.hasTemporal = false;
+
+    for (const name of constructors.keys()) {
+      exports[`isTemporal${name}`] = () => false;
+    }
+
+    return;
+  }
+
+  exports.hasTemporal = true;
+
+  for (const { 0: name, 1: brandedGetter } of constructors) {
+    const constructor = Temporal[name];
+    exports[`Temporal${name}`] = constructor;
+
+    ArrayPrototypeForEach(
+      ObjectEntries(ObjectGetOwnPropertyDescriptors(constructor)),
+      ({ 0: key, 1: desc }) => {
+        if (typeof key === 'string' && typeof desc.value === 'function') {
+          exports[`Temporal${name}${capitalizeKey(key)}`] = desc.value;
+        }
+      },
+    );
+
+    const descriptors = ObjectGetOwnPropertyDescriptors(constructor.prototype);
+    ArrayPrototypeForEach(
+      ObjectEntries(descriptors),
+      ({ 0: key, 1: desc }) => {
+        if (typeof key !== 'string') return;
+
+        if ('get' in desc) {
+          exports[`Temporal${name}PrototypeGet${capitalizeKey(key)}`] = uncurryThis(desc.get);
+        } else {
+          exports[`Temporal${name}Prototype${capitalizeKey(key)}`] = typeof desc.value === 'function' ?
+            uncurryThis(desc.value) :
+            desc.value;
+        }
+      },
+    );
+
+    exports[`isTemporal${name}`] = makeTypeCheckMethod(descriptors[brandedGetter].get);
+  }
+};
+
+function makeTypeCheckMethod(getter) {
+  return (value) => {
+    try {
+      FunctionPrototypeCall(getter, value);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+function capitalizeKey(key) {
+  return `${StringPrototypeToUpperCase(key[0])}${StringPrototypeSubstring(key, 1)}`;
+}
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 099f8d2eaf05..4268e38284f1 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -123,6 +123,7 @@ expected.beforePreExec = new Set([
 
 expected.atRunTime = new Set([
   'NativeModule internal/process/pre_execution',
+  'NativeModule internal/util/temporal',
 ]);
 
 const { isMainThread } = require('worker_threads');
diff --git a/test/parallel/test-runner-mock-timers-temporal-disabled.js b/test/parallel/test-runner-mock-timers-temporal-disabled.js
new file mode 100644
index 000000000000..d9d39f895033
--- /dev/null
+++ b/test/parallel/test-runner-mock-timers-temporal-disabled.js
@@ -0,0 +1,19 @@
+// Flags: --no-harmony-temporal
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { it, describe } = require('node:test');
+
+describe('Mock Timers Temporal.Now without Temporal', () => {
+  it('should throw when Temporal.Now is explicitly requested', (t) => {
+    assert.throws(() => {
+      t.mock.timers.enable({ apis: ['Temporal.Now'] });
+    }, { code: 'ERR_INVALID_ARG_VALUE' });
+  });
+
+  it('should silently exclude Temporal.Now from the default apis', (t) => {
+    t.mock.timers.enable({ now: 0 });
+    assert.strictEqual(Date.now(), 0);
+  });
+});
diff --git a/test/parallel/test-runner-mock-timers-temporal.js b/test/parallel/test-runner-mock-timers-temporal.js
new file mode 100644
index 000000000000..92f63a158109
--- /dev/null
+++ b/test/parallel/test-runner-mock-timers-temporal.js
@@ -0,0 +1,115 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { it, describe } = require('node:test');
+
+if (!common.hasTemporal) {
+  common.skip('No Temporal support');
+}
+
+describe('Mock Timers Temporal.Now Test Suite', () => {
+  it('should return the initial time from Temporal.Now.instant', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 100 });
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 100);
+  });
+
+  it('should return an actual Temporal.Instant instance', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'] });
+    assert.ok(Temporal.Now.instant() instanceof Temporal.Instant);
+  });
+
+  it('should accept a Date object as the initial time', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: new Date(200) });
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 200);
+  });
+
+  it('should advance with tick', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 0 });
+    t.mock.timers.tick(200);
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 200);
+  });
+
+  it('should move with setTime', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 100 });
+    t.mock.timers.setTime(1000);
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 1000);
+  });
+
+  it('should share the mock clock with Date', (t) => {
+    t.mock.timers.enable({ apis: ['Date', 'Temporal.Now'], now: 100 });
+    t.mock.timers.tick(200);
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, Date.now());
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 300);
+  });
+
+  it('should be mocked by a parameterless enable', (t) => {
+    t.mock.timers.enable();
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 0);
+  });
+
+  it('should have zero sub-millisecond digits', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 1 });
+    assert.strictEqual(Temporal.Now.instant().epochNanoseconds, 1_000_000n);
+  });
+
+  it('should not mock timeZoneId', (t) => {
+    const realTimeZoneId = Temporal.Now.timeZoneId();
+    t.mock.timers.enable({ apis: ['Temporal.Now'] });
+    assert.strictEqual(Temporal.Now.timeZoneId(), realTimeZoneId);
+  });
+
+  it('should use the mock clock for zonedDateTimeISO', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 0 });
+    const zdt = Temporal.Now.zonedDateTimeISO('UTC');
+    assert.strictEqual(zdt.epochMilliseconds, 0);
+    assert.strictEqual(zdt.year, 1970);
+    assert.strictEqual(zdt.timeZoneId, 'UTC');
+  });
+
+  it('should default zonedDateTimeISO to the system time zone', (t) => {
+    const realTimeZoneId = Temporal.Now.timeZoneId();
+    t.mock.timers.enable({ apis: ['Temporal.Now'] });
+    assert.strictEqual(
+      Temporal.Now.zonedDateTimeISO().timeZoneId, realTimeZoneId);
+  });
+
+  it('should derive plainDateTimeISO from the mock clock', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 0 });
+    assert.strictEqual(
+      Temporal.Now.plainDateTimeISO('UTC').toString(), '1970-01-01T00:00:00');
+  });
+
+  it('should derive plainDateISO from the mock clock', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 0 });
+    assert.strictEqual(
+      Temporal.Now.plainDateISO('UTC').toString(), '1970-01-01');
+  });
+
+  it('should derive plainTimeISO from the mock clock', (t) => {
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 0 });
+    assert.strictEqual(
+      Temporal.Now.plainTimeISO('UTC').toString(), '00:00:00');
+  });
+
+  it('should restore the real methods on reset', (t) => {
+    const realInstant = Temporal.Now.instant;
+    const realZonedDateTimeISO = Temporal.Now.zonedDateTimeISO;
+    t.mock.timers.enable({ apis: ['Temporal.Now'] });
+    assert.notStrictEqual(Temporal.Now.instant, realInstant);
+    t.mock.timers.reset();
+    assert.strictEqual(Temporal.Now.instant, realInstant);
+    assert.strictEqual(Temporal.Now.zonedDateTimeISO, realZonedDateTimeISO);
+  });
+
+  it('should not be affected by a tampered global Temporal', (t) => {
+    const realFromEpochMilliseconds = Temporal.Instant.fromEpochMilliseconds;
+    t.after(() => {
+      Temporal.Instant.fromEpochMilliseconds = realFromEpochMilliseconds;
+    });
+
+    Temporal.Instant.fromEpochMilliseconds = common.mustNotCall();
+    t.mock.timers.enable({ apis: ['Temporal.Now'], now: 100 });
+    assert.strictEqual(Temporal.Now.instant().epochMilliseconds, 100);
+  });
+});
diff --git a/test/parallel/test-temporal-utils-no-temporal.js b/test/parallel/test-temporal-utils-no-temporal.js
new file mode 100644
index 000000000000..d1ca2c4c0ea4
--- /dev/null
+++ b/test/parallel/test-temporal-utils-no-temporal.js
@@ -0,0 +1,18 @@
+// Flags: --expose-internals --no-harmony-temporal --no-warnings
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+common.allowGlobals(globalThis.Temporal = {
+  Instant: class Instant {},
+});
+
+const instant = new Temporal.Instant();
+
+// Module contents should be independent of global state at require time
+const temporalUtils = require('internal/util/temporal');
+
+assert.strictEqual(temporalUtils.hasTemporal, false);
+assert.strictEqual(temporalUtils.isTemporalInstant(instant), false);
diff --git a/test/parallel/test-temporal-utils.js b/test/parallel/test-temporal-utils.js
new file mode 100644
index 000000000000..d7354a651311
--- /dev/null
+++ b/test/parallel/test-temporal-utils.js
@@ -0,0 +1,25 @@
+// Flags: --expose-internals --no-warnings
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.hasTemporal) {
+  common.skip('No Temporal support');
+}
+
+const instant = Temporal.Now.instant();
+
+delete globalThis.Temporal;
+assert.strictEqual(typeof Temporal, 'undefined');
+
+// Module contents should be independent of global state at require time
+const temporalUtils = require('internal/util/temporal');
+
+assert.strictEqual(temporalUtils.hasTemporal, true);
+assert.strictEqual(instant.constructor, temporalUtils.TemporalInstant);
+assert.strictEqual(instant.epochNanoseconds,
+                   temporalUtils.TemporalInstantPrototypeGetEpochNanoseconds(instant));
+assert.strictEqual(temporalUtils.isTemporalInstant(instant), true);
+assert.strictEqual(temporalUtils.isTemporalZonedDateTime(instant), false);