chronokinesis 7.0.1 → 8.0.0

package/README.md

@@ -7,6 +7,7 @@ Mock time and date for traveling and freezing. Inspired and borrowed from [timek
 <!-- toc -->
 
 - [Introduction](#introduction)
+- [Examples](#examples)
 - [API Reference](#api-reference)
   - [`freeze([...args])`](#freezeargs)
   - [`travel([...args])`](#travelargs)
@@ -15,21 +16,26 @@ Mock time and date for traveling and freezing. Inspired and borrowed from [timek
   - [`isKeepingTime()`](#iskeepingtime)
   - [`timezone(timeZone[, ...args])`](#timezonetimezone-args)
   - [`new TimeZoneTraveller(timeZone)`](#new-timezonetravellertimezone)
-    - [`timezone.freeze([...args])`](#timezonefreezeargs)
-    - [`timezone.travel([...args])`](#timezonetravelargs)
-    - [`timezone.reset()`](#timezonereset)
-    - [`timezone.defrost()`](#timezonedefrost)
+  - [`timezone.freeze([...args])`](#timezonefreezeargs)
+  - [`timezone.travel([...args])`](#timezonetravelargs)
+  - [`timezone.reset()`](#timezonereset)
+  - [`timezone.defrost()`](#timezonedefrost)
 - [Distributions](#distributions)
   - [Nodejs require](#nodejs-require)
   - [Browser (UMD)](#browser-umd)
+- [High-resolution clocks](#high-resolution-clocks)
+- [chronokinesis vs `node:test` mock timers](#chronokinesis-vs-nodetest-mock-timers)
+- [Caveats when mocking high-resolution clocks](#caveats-when-mocking-high-resolution-clocks)
 - [Acknowledgements](#acknowledgements)
 
 <!-- tocstop -->
 
-# Introduction
+## Introduction
 
 Mock `Date` and `Date.now` in order to help you test time-dependent code. Provides `travel`, `freeze`, and timezone functionality for your Node.js tests.
 
+## Examples
+
 ```javascript
 import * as ck from 'chronokinesis';
 
@@ -87,9 +93,9 @@ setTimeout(() => {
 }, 2000);
 ```
 
-# API Reference
+## API Reference
 
-## `freeze([...args])`
+### `freeze([...args])`
 
 Freeze point in time. Calls can be made with the same arguments as the `Date` constructor.
 
@@ -108,7 +114,7 @@ setTimeout(() => {
 }, 2000);
 ```
 
-## `travel([...args])`
+### `travel([...args])`
 
 Time travel to another era. Calls can be made with the same arguments as the `Date` constructor
 
@@ -145,7 +151,7 @@ setTimeout(function () {
 }, 1500);
 ```
 
-## `defrost()`
+### `defrost()`
 
 Defrost a frozen point in time. Used in combination with travelling will start ticking the clock.
 
@@ -168,7 +174,7 @@ setTimeout(() => {
 }, 2000);
 ```
 
-## `reset()`
+### `reset()`
 
 Resets Date to current glory.
 
@@ -184,7 +190,7 @@ ck.reset();
 console.log(new Date());
 ```
 
-## `isKeepingTime()`
+### `isKeepingTime()`
 
 Utility function to see if we still travel or freeze time.
 
@@ -198,7 +204,7 @@ console.log(ck.isKeepingTime() ? 'Is' : 'Not', 'keeping time');
 ck.reset();
 ```
 
-## `timezone(timeZone[, ...args])`
+### `timezone(timeZone[, ...args])`
 
 Travel to time zone.
 
@@ -221,7 +227,7 @@ tz.freeze();
 ck.reset();
 ```
 
-## `new TimeZoneTraveller(timeZone)`
+### `new TimeZoneTraveller(timeZone)`
 
 Time zone traveller api.
 
@@ -251,20 +257,63 @@ Same as [#reset](#reset)
 
 Same as [#defrost](#defrost)
 
-# Distributions
+## Distributions
 
 The module is prepared for browser and nodejs.
 
-## Nodejs require
+### Nodejs require
 
 ```js
 const ck = require('chronokinesis');
 ```
 
-## Browser (UMD)
+### Browser (UMD)
 
 Use `dist/chronokinesis.cjs`. Sets global property `chronokinesis`.
 
-# Acknowledgements
+## High-resolution clocks
+
+`process.hrtime`, `process.hrtime.bigint()` and `performance.now()` are mocked alongside `Date` while timekeeping is active. The fake clocks stay on the native monotonic scale — each `freeze(T)` / `travel(T)` call shifts them by `(T − previousMockedMs)`, so readings before and after the mock are directly comparable. `freeze()` additionally locks the value so repeated reads return the same result. `reset()` clears the shift and restores the native functions by identity.
+
+Because the fake and native axes are aligned, a pre-mock baseline can be diffed meaningfully against a reading taken after travelling forward:
+
+```javascript
+import * as ck from 'chronokinesis';
+
+const baseHr = process.hrtime.bigint();
+const basePerf = performance.now();
+const baseMs = Date.now();
+
+ck.freeze(baseMs);
+ck.travel(baseMs + 1000);
+
+console.log(Number(process.hrtime.bigint() - baseHr) / 1e6); // ≈ 1000 (ms)
+console.log(performance.now() - basePerf); //                    ≈ 1000 (ms)
+
+ck.reset();
+```
+
+## chronokinesis vs `node:test` mock timers
+
+chronokinesis mocks **clocks only** — `Date`, `process.hrtime`, `performance.now`. Timers (`setTimeout`, `setInterval`, `setImmediate`) still run on the real wall clock; a `setTimeout(fn, 10)` under `freeze()` still fires ~10ms later in real time.
+
+Node's built-in `node:test` provides `mock.timers` which is different: it mocks both the clock **and** the timer queue, and `mock.timers.tick(ms)` synchronously advances time and fires any timers scheduled within that window — no real waiting required.
+
+Rule of thumb:
+
+- Use **chronokinesis** to pin the wall-clock/timezone to a specific moment while letting real timers run — e.g. you want `new Date()` to return 1980-01-01 but your `setTimeout(..., 10)` should still take 10ms.
+- Use **`node:test` `mock.timers`** to fast-forward deterministically through timer-based logic without waiting real time.
+- Don't enable both simultaneously; they both own `Date`.
+
+## Caveats when mocking high-resolution clocks
+
+Swapping `process.hrtime` and `performance.now` is generally safe — `fetch`, `AbortSignal.timeout`, `setTimeout`, `setInterval`, and other libuv-backed APIs are unaffected (they use `uv_hrtime`, which chronokinesis does not touch). A few things are worth knowing:
+
+- **`performance.mark` + `performance.measure` across a mock boundary are meaningless.** A mark captured before `freeze()`/`travel()` and a measure taken after produces a fabricated duration — the hrtime axis shifted by the mock delta in between.
+- **Long-lived resources with hrtime-based idle or keep-alive timers** (database pools, HTTP keep-alive, gRPC deadlines) may misbehave if they were acquired before the mock. Prefer to mock before creating such resources and reset after tearing them down.
+- **Tracing / metrics / structured logging** (pino, OpenTelemetry, APM agents) will emit bogus timestamps under mock. Fine for unit tests; don't assert on telemetry timing in mocked phases.
+- **Monotonicity holds within a single `freeze()` or `travel()` phase**, but not across them — `reset()` snaps back to native, and `travel(past)` can move values backwards relative to earlier readings.
+
+## Acknowledgements
 
 chronokinesis initial code is inspired and borrowed from [timekeeper](https://github.com/vesln/timekeeper)

package/dist/chronokinesis.cjs

@@ -15,10 +15,28 @@
   const NativeDate = Date[kNativeDate] || Date;
   const nativeGetTimezoneOffset = NativeDate.prototype.getTimezoneOffset;
 
+  /* c8 ignore start -- environment-capability guards; false branches only hit in browser (isomorphic test) */
+  const nativeProcess = typeof process !== 'undefined' ? process : null;
+  const nativeHrtime = nativeProcess && typeof nativeProcess.hrtime === 'function' ? nativeProcess.hrtime : null;
+  const nativeHrtimeBigint = nativeHrtime && typeof nativeHrtime.bigint === 'function' ? nativeHrtime.bigint : null;
+  const nativePerformance = typeof performance !== 'undefined' ? performance : null;
+  const nativePerformanceNow = nativePerformance && typeof nativePerformance.now === 'function' ? nativePerformance.now : null;
+
+  // Anchor native perf.now against native hrtime at module load so that later reads
+  // can reconstruct real native perf.now even when process.hrtime has been swapped
+  // (Node <22 wires performance.now to process.hrtime internally).
+  const perfAnchorMs = nativePerformanceNow ? nativePerformanceNow.call(nativePerformance) : 0;
+  const hrtimeAnchorNs = nativeHrtimeBigint ? nativeHrtimeBigint.call(nativeProcess) : 0n;
+  /* c8 ignore stop */
+
   let freezedAt = null;
   let traveledTo = null;
   let started = null;
   let iana = null;
+  let hrtimeOffset = 0n;
+  let performanceNowOffset = 0;
+  let freezedHrtimeNs = null;
+  let freezedPerformanceNow = null;
 
   function FakeDate(...args) {
     const length = args.length;
@@ -57,16 +75,21 @@
 
   function freeze(...args) {
     useFakeDate();
-    freezedAt = instantiate(Date, args);
-    if (isNaN(freezedAt)) {
+    const target = instantiate(Date, args);
+    if (isNaN(target)) {
       reset();
       throw new TypeError('Chronokinesis cannot freeze to invalid date, check your arguments. Chronokinesis is reset');
     }
+    const prevMockedMs = currentMockedMs();
+    freezedAt = target;
+    shiftAndLockFakeClocks(target.getTime() - prevMockedMs);
     return freezedAt;
   }
 
   function defrost() {
     freezedAt = null;
+    freezedHrtimeNs = null;
+    freezedPerformanceNow = null;
   }
 
   function travel(...args) {
@@ -77,13 +100,21 @@
       throw new TypeError('Chronokinesis cannot travel to invalid date, check your arguments. Chronokinesis is reset');
     }
 
-    traveledTo = travelToDate.getTime();
-    started = NativeDate.now();
+    const prevMockedMs = currentMockedMs();
+    const targetMs = travelToDate.getTime();
+    const deltaMs = targetMs - prevMockedMs;
+    if (nativeHrtimeBigint) hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+    if (nativePerformanceNow) performanceNowOffset += deltaMs;
 
     if (freezedAt) {
       freezedAt = travelToDate;
+      if (nativeHrtimeBigint) freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+      if (nativePerformanceNow) freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
     }
 
+    traveledTo = targetMs;
+    started = NativeDate.now();
+
     return travelToDate;
   }
 
@@ -93,6 +124,10 @@
     started = null;
     traveledTo = null;
     iana = null;
+    hrtimeOffset = 0n;
+    performanceNowOffset = 0;
+    freezedHrtimeNs = null;
+    freezedPerformanceNow = null;
   }
 
   function isKeepingTime() {
@@ -151,16 +186,78 @@
 
   function useFakeDate() {
     Date = FakeDate;
+    if (nativeHrtime) nativeProcess.hrtime = fakeHrtime;
+    if (nativePerformanceNow) {
+      Object.defineProperty(nativePerformance, 'now', { value: fakePerformanceNow, configurable: true, writable: true });
+    }
   }
 
   function useNativeDate() {
     Date = FakeDate[kNativeDate];
+    if (nativeHrtime) nativeProcess.hrtime = nativeHrtime;
+    if (nativePerformanceNow) {
+      Object.defineProperty(nativePerformance, 'now', { value: nativePerformanceNow, configurable: true, writable: true });
+    }
   }
 
   function time() {
     return traveledTo + (NativeDate.now() - started);
   }
 
+  function currentMockedMs() {
+    if (freezedAt) return freezedAt.getTime();
+    if (traveledTo !== null) return time();
+    return NativeDate.now();
+  }
+
+  function nativePerformanceNowFromHrtime() {
+    if (nativeHrtimeBigint) {
+      const elapsedNs = nativeHrtimeBigint.call(nativeProcess) - hrtimeAnchorNs;
+      return perfAnchorMs + Number(elapsedNs) / 1_000_000;
+    }
+    /* c8 ignore next -- browser fallback; covered by isomorphic test, not by Node c8 */
+    return nativePerformanceNow.call(nativePerformance);
+  }
+
+  function shiftAndLockFakeClocks(deltaMs) {
+    if (nativeHrtimeBigint) {
+      hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+      freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+    }
+    if (nativePerformanceNow) {
+      performanceNowOffset += deltaMs;
+      freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
+    }
+  }
+
+  function fakeHrtimeNs() {
+    if (freezedHrtimeNs !== null) return freezedHrtimeNs;
+    return nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+  }
+
+  function fakeHrtime(prev) {
+    const total = fakeHrtimeNs();
+    const sec = Number(total / 1_000_000_000n);
+    const ns = Number(total % 1_000_000_000n);
+    if (!prev) return [sec, ns];
+    let ds = sec - prev[0];
+    let dn = ns - prev[1];
+    if (dn < 0) {
+      ds -= 1;
+      dn += 1_000_000_000;
+    }
+    return [ds, dn];
+  }
+
+  fakeHrtime.bigint = function fakeHrtimeBigint() {
+    return fakeHrtimeNs();
+  };
+
+  function fakePerformanceNow() {
+    if (freezedPerformanceNow !== null) return freezedPerformanceNow;
+    return nativePerformanceNowFromHrtime() + performanceNowOffset;
+  }
+
   function instantiate(type, args) {
     const ctorArgs = args.slice();
     ctorArgs.unshift(null);

package/dist/index.cjs

@@ -11,10 +11,28 @@ const kNativeDate = Symbol.for('chronokinesis native date');
 const NativeDate = Date[kNativeDate] || Date;
 const nativeGetTimezoneOffset = NativeDate.prototype.getTimezoneOffset;
 
+/* c8 ignore start -- environment-capability guards; false branches only hit in browser (isomorphic test) */
+const nativeProcess = typeof process !== 'undefined' ? process : null;
+const nativeHrtime = nativeProcess && typeof nativeProcess.hrtime === 'function' ? nativeProcess.hrtime : null;
+const nativeHrtimeBigint = nativeHrtime && typeof nativeHrtime.bigint === 'function' ? nativeHrtime.bigint : null;
+const nativePerformance = typeof performance !== 'undefined' ? performance : null;
+const nativePerformanceNow = nativePerformance && typeof nativePerformance.now === 'function' ? nativePerformance.now : null;
+
+// Anchor native perf.now against native hrtime at module load so that later reads
+// can reconstruct real native perf.now even when process.hrtime has been swapped
+// (Node <22 wires performance.now to process.hrtime internally).
+const perfAnchorMs = nativePerformanceNow ? nativePerformanceNow.call(nativePerformance) : 0;
+const hrtimeAnchorNs = nativeHrtimeBigint ? nativeHrtimeBigint.call(nativeProcess) : 0n;
+/* c8 ignore stop */
+
 let freezedAt = null;
 let traveledTo = null;
 let started = null;
 let iana = null;
+let hrtimeOffset = 0n;
+let performanceNowOffset = 0;
+let freezedHrtimeNs = null;
+let freezedPerformanceNow = null;
 
 function FakeDate(...args) {
   const length = args.length;
@@ -53,16 +71,21 @@ FakeDate.now = function fakeNow() {
 
 function freeze(...args) {
   useFakeDate();
-  freezedAt = instantiate(Date, args);
-  if (isNaN(freezedAt)) {
+  const target = instantiate(Date, args);
+  if (isNaN(target)) {
     reset();
     throw new TypeError('Chronokinesis cannot freeze to invalid date, check your arguments. Chronokinesis is reset');
   }
+  const prevMockedMs = currentMockedMs();
+  freezedAt = target;
+  shiftAndLockFakeClocks(target.getTime() - prevMockedMs);
   return freezedAt;
 }
 
 function defrost() {
   freezedAt = null;
+  freezedHrtimeNs = null;
+  freezedPerformanceNow = null;
 }
 
 function travel(...args) {
@@ -73,13 +96,21 @@ function travel(...args) {
     throw new TypeError('Chronokinesis cannot travel to invalid date, check your arguments. Chronokinesis is reset');
   }
 
-  traveledTo = travelToDate.getTime();
-  started = NativeDate.now();
+  const prevMockedMs = currentMockedMs();
+  const targetMs = travelToDate.getTime();
+  const deltaMs = targetMs - prevMockedMs;
+  if (nativeHrtimeBigint) hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+  if (nativePerformanceNow) performanceNowOffset += deltaMs;
 
   if (freezedAt) {
     freezedAt = travelToDate;
+    if (nativeHrtimeBigint) freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+    if (nativePerformanceNow) freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
   }
 
+  traveledTo = targetMs;
+  started = NativeDate.now();
+
   return travelToDate;
 }
 
@@ -89,6 +120,10 @@ function reset() {
   started = null;
   traveledTo = null;
   iana = null;
+  hrtimeOffset = 0n;
+  performanceNowOffset = 0;
+  freezedHrtimeNs = null;
+  freezedPerformanceNow = null;
 }
 
 function isKeepingTime() {
@@ -147,16 +182,78 @@ function timezone(timeZone, ...args) {
 
 function useFakeDate() {
   Date = FakeDate;
+  if (nativeHrtime) nativeProcess.hrtime = fakeHrtime;
+  if (nativePerformanceNow) {
+    Object.defineProperty(nativePerformance, 'now', { value: fakePerformanceNow, configurable: true, writable: true });
+  }
 }
 
 function useNativeDate() {
   Date = FakeDate[kNativeDate];
+  if (nativeHrtime) nativeProcess.hrtime = nativeHrtime;
+  if (nativePerformanceNow) {
+    Object.defineProperty(nativePerformance, 'now', { value: nativePerformanceNow, configurable: true, writable: true });
+  }
 }
 
 function time() {
   return traveledTo + (NativeDate.now() - started);
 }
 
+function currentMockedMs() {
+  if (freezedAt) return freezedAt.getTime();
+  if (traveledTo !== null) return time();
+  return NativeDate.now();
+}
+
+function nativePerformanceNowFromHrtime() {
+  if (nativeHrtimeBigint) {
+    const elapsedNs = nativeHrtimeBigint.call(nativeProcess) - hrtimeAnchorNs;
+    return perfAnchorMs + Number(elapsedNs) / 1_000_000;
+  }
+  /* c8 ignore next -- browser fallback; covered by isomorphic test, not by Node c8 */
+  return nativePerformanceNow.call(nativePerformance);
+}
+
+function shiftAndLockFakeClocks(deltaMs) {
+  if (nativeHrtimeBigint) {
+    hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+    freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+  }
+  if (nativePerformanceNow) {
+    performanceNowOffset += deltaMs;
+    freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
+  }
+}
+
+function fakeHrtimeNs() {
+  if (freezedHrtimeNs !== null) return freezedHrtimeNs;
+  return nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+}
+
+function fakeHrtime(prev) {
+  const total = fakeHrtimeNs();
+  const sec = Number(total / 1_000_000_000n);
+  const ns = Number(total % 1_000_000_000n);
+  if (!prev) return [sec, ns];
+  let ds = sec - prev[0];
+  let dn = ns - prev[1];
+  if (dn < 0) {
+    ds -= 1;
+    dn += 1_000_000_000;
+  }
+  return [ds, dn];
+}
+
+fakeHrtime.bigint = function fakeHrtimeBigint() {
+  return fakeHrtimeNs();
+};
+
+function fakePerformanceNow() {
+  if (freezedPerformanceNow !== null) return freezedPerformanceNow;
+  return nativePerformanceNowFromHrtime() + performanceNowOffset;
+}
+
 function instantiate(type, args) {
   const ctorArgs = args.slice();
   ctorArgs.unshift(null);

package/index.js

@@ -9,10 +9,28 @@ const kNativeDate = Symbol.for('chronokinesis native date');
 const NativeDate = Date[kNativeDate] || Date;
 const nativeGetTimezoneOffset = NativeDate.prototype.getTimezoneOffset;
 
+/* c8 ignore start -- environment-capability guards; false branches only hit in browser (isomorphic test) */
+const nativeProcess = typeof process !== 'undefined' ? process : null;
+const nativeHrtime = nativeProcess && typeof nativeProcess.hrtime === 'function' ? nativeProcess.hrtime : null;
+const nativeHrtimeBigint = nativeHrtime && typeof nativeHrtime.bigint === 'function' ? nativeHrtime.bigint : null;
+const nativePerformance = typeof performance !== 'undefined' ? performance : null;
+const nativePerformanceNow = nativePerformance && typeof nativePerformance.now === 'function' ? nativePerformance.now : null;
+
+// Anchor native perf.now against native hrtime at module load so that later reads
+// can reconstruct real native perf.now even when process.hrtime has been swapped
+// (Node <22 wires performance.now to process.hrtime internally).
+const perfAnchorMs = nativePerformanceNow ? nativePerformanceNow.call(nativePerformance) : 0;
+const hrtimeAnchorNs = nativeHrtimeBigint ? nativeHrtimeBigint.call(nativeProcess) : 0n;
+/* c8 ignore stop */
+
 let freezedAt = null;
 let traveledTo = null;
 let started = null;
 let iana = null;
+let hrtimeOffset = 0n;
+let performanceNowOffset = 0;
+let freezedHrtimeNs = null;
+let freezedPerformanceNow = null;
 
 export function FakeDate(...args) {
   const length = args.length;
@@ -51,16 +69,21 @@ FakeDate.now = function fakeNow() {
 
 export function freeze(...args) {
   useFakeDate();
-  freezedAt = instantiate(Date, args);
-  if (isNaN(freezedAt)) {
+  const target = instantiate(Date, args);
+  if (isNaN(target)) {
     reset();
     throw new TypeError('Chronokinesis cannot freeze to invalid date, check your arguments. Chronokinesis is reset');
   }
+  const prevMockedMs = currentMockedMs();
+  freezedAt = target;
+  shiftAndLockFakeClocks(target.getTime() - prevMockedMs);
   return freezedAt;
 }
 
 export function defrost() {
   freezedAt = null;
+  freezedHrtimeNs = null;
+  freezedPerformanceNow = null;
 }
 
 export function travel(...args) {
@@ -71,13 +94,21 @@ export function travel(...args) {
     throw new TypeError('Chronokinesis cannot travel to invalid date, check your arguments. Chronokinesis is reset');
   }
 
-  traveledTo = travelToDate.getTime();
-  started = NativeDate.now();
+  const prevMockedMs = currentMockedMs();
+  const targetMs = travelToDate.getTime();
+  const deltaMs = targetMs - prevMockedMs;
+  if (nativeHrtimeBigint) hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+  if (nativePerformanceNow) performanceNowOffset += deltaMs;
 
   if (freezedAt) {
     freezedAt = travelToDate;
+    if (nativeHrtimeBigint) freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+    if (nativePerformanceNow) freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
   }
 
+  traveledTo = targetMs;
+  started = NativeDate.now();
+
   return travelToDate;
 }
 
@@ -87,6 +118,10 @@ export function reset() {
   started = null;
   traveledTo = null;
   iana = null;
+  hrtimeOffset = 0n;
+  performanceNowOffset = 0;
+  freezedHrtimeNs = null;
+  freezedPerformanceNow = null;
 }
 
 export function isKeepingTime() {
@@ -145,16 +180,78 @@ export function timezone(timeZone, ...args) {
 
 function useFakeDate() {
   Date = FakeDate;
+  if (nativeHrtime) nativeProcess.hrtime = fakeHrtime;
+  if (nativePerformanceNow) {
+    Object.defineProperty(nativePerformance, 'now', { value: fakePerformanceNow, configurable: true, writable: true });
+  }
 }
 
 function useNativeDate() {
   Date = FakeDate[kNativeDate];
+  if (nativeHrtime) nativeProcess.hrtime = nativeHrtime;
+  if (nativePerformanceNow) {
+    Object.defineProperty(nativePerformance, 'now', { value: nativePerformanceNow, configurable: true, writable: true });
+  }
 }
 
 function time() {
   return traveledTo + (NativeDate.now() - started);
 }
 
+function currentMockedMs() {
+  if (freezedAt) return freezedAt.getTime();
+  if (traveledTo !== null) return time();
+  return NativeDate.now();
+}
+
+function nativePerformanceNowFromHrtime() {
+  if (nativeHrtimeBigint) {
+    const elapsedNs = nativeHrtimeBigint.call(nativeProcess) - hrtimeAnchorNs;
+    return perfAnchorMs + Number(elapsedNs) / 1_000_000;
+  }
+  /* c8 ignore next -- browser fallback; covered by isomorphic test, not by Node c8 */
+  return nativePerformanceNow.call(nativePerformance);
+}
+
+function shiftAndLockFakeClocks(deltaMs) {
+  if (nativeHrtimeBigint) {
+    hrtimeOffset += BigInt(deltaMs) * 1_000_000n;
+    freezedHrtimeNs = nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+  }
+  if (nativePerformanceNow) {
+    performanceNowOffset += deltaMs;
+    freezedPerformanceNow = nativePerformanceNowFromHrtime() + performanceNowOffset;
+  }
+}
+
+function fakeHrtimeNs() {
+  if (freezedHrtimeNs !== null) return freezedHrtimeNs;
+  return nativeHrtimeBigint.call(nativeProcess) + hrtimeOffset;
+}
+
+function fakeHrtime(prev) {
+  const total = fakeHrtimeNs();
+  const sec = Number(total / 1_000_000_000n);
+  const ns = Number(total % 1_000_000_000n);
+  if (!prev) return [sec, ns];
+  let ds = sec - prev[0];
+  let dn = ns - prev[1];
+  if (dn < 0) {
+    ds -= 1;
+    dn += 1_000_000_000;
+  }
+  return [ds, dn];
+}
+
+fakeHrtime.bigint = function fakeHrtimeBigint() {
+  return fakeHrtimeNs();
+};
+
+function fakePerformanceNow() {
+  if (freezedPerformanceNow !== null) return freezedPerformanceNow;
+  return nativePerformanceNowFromHrtime() + performanceNowOffset;
+}
+
 function instantiate(type, args) {
   const ctorArgs = args.slice();
   ctorArgs.unshift(null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronokinesis",
-  "version": "7.0.1",
+  "version": "8.0.0",
   "description": "Module for testing time-dependent code",
   "author": {
     "name": "Pål Edman",
@@ -44,6 +44,8 @@
   "keywords": [
     "date",
     "time",
+    "hrtime",
+    "performance",
     "timezone",
     "fake",
     "mock",
@@ -58,6 +60,7 @@
     "c8": "^10.1.2",
     "chai": "^6.2.0",
     "eslint": "^9.3.0",
+    "happy-dom": "^17.6.1",
     "lodash.clonedeep": "^4.5.0",
     "luxon": "^3.7.1",
     "markdown-toc": "^1.2.0",
@@ -65,6 +68,6 @@
     "moment": "^2.30.1",
     "prettier": "^3.2.5",
     "rollup": "^4.12.1",
-    "texample": "^0.0.8"
+    "texample": "^0.1.0"
   }
 }