@crashlab/clock 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# @crashlab/clock
+
+Deterministic virtual clock for Node.js. Replaces `Date`, `setTimeout`, `setInterval`, `clearTimeout`, `clearInterval`, and `performance.now()` with manually-controllable fakes.
+
+## Usage
+
+```ts
+import { VirtualClock, install } from '@crashlab/clock';
+
+// Standalone (no global patching)
+const clock = new VirtualClock(0);
+const order: number[] = [];
+clock.setTimeout(() => order.push(1), 100);
+clock.setTimeout(() => order.push(2), 200);
+clock.advance(200);
+// order = [1, 2]
+
+// With global patching
+const { clock: c, uninstall } = install(0);
+console.log(Date.now()); // 0
+c.advance(5000);
+console.log(Date.now()); // 5000
+uninstall();
+```
+
+## Key Features
+
+- **Min-heap timer queue** — O(log n) insertion and removal
+- **Deterministic ordering** — same-time timers fire in FIFO order
+- **Cascading timers** — timers that schedule sub-timers within the same `advance()` window are picked up and executed in order
+- **`freeze()` / `unfreeze()`** — pause time progression
+- **`pending()`** — inspect all scheduled timers

package/dist/MinHeap.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generic min-heap priority queue.
+ * O(log n) push/pop, used as the timer scheduling backbone.
+ */
+export declare class MinHeap<T> {
+    private readonly comparator;
+    private heap;
+    constructor(comparator: (a: T, b: T) => number);
+    get size(): number;
+    peek(): T | undefined;
+    push(value: T): void;
+    pop(): T | undefined;
+    /** Remove first entry matching predicate. Returns true if found. */
+    remove(predicate: (v: T) => boolean): boolean;
+    toArray(): T[];
+    private bubbleUp;
+    private sinkDown;
+}
+//# sourceMappingURL=MinHeap.d.ts.map

package/dist/MinHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinHeap.d.ts","sourceRoot":"","sources":["../src/MinHeap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,OAAO,CAAC,CAAC;IAGR,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,OAAO,CAAC,IAAI,CAAW;gBAEM,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAE/D,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAKpB,GAAG,IAAI,CAAC,GAAG,SAAS;IAYpB,oEAAoE;IACpE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO;IAY7C,OAAO,IAAI,CAAC,EAAE;IAId,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,QAAQ;CAejB"}

package/dist/VirtualClock.d.ts

@@ -0,0 +1,66 @@
+/** Internal timer entry stored in the heap. */
+export interface TimerEntry {
+    id: number;
+    callback: (...args: unknown[]) => void | Promise<void>;
+    scheduledTime: number;
+    interval?: number;
+    args: unknown[];
+}
+/**
+ * A manually-controllable virtual clock.
+ *
+ * Replaces all time primitives so that `advance(duration)` fires timers
+ * deterministically, in scheduled-time order.  Timers that schedule new
+ * timers within the same advance window ARE picked up and executed in
+ * the correct order (the heap is re-checked after every callback).
+ */
+export declare class VirtualClock {
+    private _now;
+    private _skew;
+    private _nextId;
+    private _frozen;
+    private _timers;
+    private readonly _cancelledIds;
+    private readonly _virtualNextTickQueue;
+    private readonly _virtualImmediateQueue;
+    private _nextImmediateId;
+    private readonly _cancelledImmediates;
+    /**
+     * Optional hook called after each timer fires (and after microtask flush).
+     * The clock attaches the scheduler here so that advancing time drives I/O.
+     */
+    onTick?: (time: number) => Promise<void>;
+    constructor(startTime?: number);
+    now(): number;
+    pending(): Array<{
+        id: number;
+        scheduledTime: number;
+    }>;
+    /**
+     * Advance the clock by `duration` ms, firing every timer whose
+     * scheduled time falls within `[now, now + duration]` in order.
+     */
+    advance(duration: number): Promise<void>;
+    /**
+     * Jump to an absolute virtual timestamp, draining timers along the way.
+     */
+    advanceTo(timestamp: number): Promise<void>;
+    private _flushMicrotasks;
+    private _flushImmediates;
+    freeze(): void;
+    unfreeze(): void;
+    /**
+     * Apply a clock skew offset (ms). Does NOT fire timers.
+     * `now()` returns `_now + _skew`.
+     */
+    skew(amount: number): void;
+    setTimeout(callback: (...args: unknown[]) => void | Promise<void>, delay?: number, ...args: unknown[]): number;
+    setInterval(callback: (...args: unknown[]) => void | Promise<void>, delay: number, ...args: unknown[]): number;
+    clearTimeout(id: number): void;
+    clearInterval(id: number): void;
+    setImmediate(callback: (...args: unknown[]) => void | Promise<void>, ...args: unknown[]): number;
+    clearImmediate(id: number): void;
+    nextTick(callback: (...args: unknown[]) => void, ...args: unknown[]): void;
+    reset(startTime?: number): void;
+}
+//# sourceMappingURL=VirtualClock.d.ts.map

package/dist/VirtualClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualClock.d.ts","sourceRoot":"","sources":["../src/VirtualClock.ts"],"names":[],"mappings":"AAEA,+CAA+C;AAC/C,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IAEnD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA2C;IACjF,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAuG;IAC9I,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;IAE1D;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;gBAE7B,SAAS,GAAE,MAAU;IAWjC,GAAG,IAAI,MAAM;IAIb,OAAO,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IASvD;;;OAGG;IACG,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C;;OAEG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAkEnC,gBAAgB;YAsBhB,gBAAgB;IAmB9B,MAAM,IAAI,IAAI;IAId,QAAQ,IAAI,IAAI;IAIhB;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM1B,UAAU,CACR,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACtD,KAAK,GAAE,MAAU,EACjB,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,MAAM;IAWT,WAAW,CACT,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACtD,KAAK,EAAE,MAAM,EACb,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,MAAM;IAYT,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAK9B,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAK/B,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM;IAMhG,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIhC,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAM1E,KAAK,CAAC,SAAS,GAAE,MAAU,GAAG,IAAI;CAiBnC"}

package/dist/VirtualDate.d.ts

@@ -0,0 +1,7 @@
+import type { VirtualClock } from './VirtualClock.js';
+/**
+ * Build a `DateConstructor` whose `now()` and zero-arg `new Date()`
+ * read from the supplied VirtualClock.
+ */
+export declare function createVirtualDate(clock: VirtualClock): DateConstructor;
+//# sourceMappingURL=VirtualDate.d.ts.map

package/dist/VirtualDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualDate.d.ts","sourceRoot":"","sources":["../src/VirtualDate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAmCtE"}

package/dist/index.cjs

@@ -0,0 +1,370 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MinHeap: () => MinHeap,
+  VirtualClock: () => VirtualClock,
+  createVirtualDate: () => createVirtualDate,
+  install: () => install
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/MinHeap.ts
+var MinHeap = class {
+  constructor(comparator) {
+    this.comparator = comparator;
+  }
+  heap = [];
+  get size() {
+    return this.heap.length;
+  }
+  peek() {
+    return this.heap[0];
+  }
+  push(value) {
+    this.heap.push(value);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  pop() {
+    const n = this.heap.length;
+    if (n === 0) return void 0;
+    const top = this.heap[0];
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return top;
+  }
+  /** Remove first entry matching predicate. Returns true if found. */
+  remove(predicate) {
+    const idx = this.heap.findIndex(predicate);
+    if (idx === -1) return false;
+    const last = this.heap.pop();
+    if (idx < this.heap.length) {
+      this.heap[idx] = last;
+      this.bubbleUp(idx);
+      this.sinkDown(idx);
+    }
+    return true;
+  }
+  toArray() {
+    return [...this.heap];
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.comparator(this.heap[i], this.heap[parent]) >= 0) break;
+      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];
+      i = parent;
+    }
+  }
+  sinkDown(i) {
+    const n = this.heap.length;
+    while (true) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < n && this.comparator(this.heap[left], this.heap[smallest]) < 0)
+        smallest = left;
+      if (right < n && this.comparator(this.heap[right], this.heap[smallest]) < 0)
+        smallest = right;
+      if (smallest === i) break;
+      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];
+      i = smallest;
+    }
+  }
+};
+
+// src/VirtualClock.ts
+var VirtualClock = class {
+  _now;
+  _skew = 0;
+  _nextId = 1;
+  _frozen = false;
+  _timers;
+  _cancelledIds = /* @__PURE__ */ new Set();
+  _virtualNextTickQueue = [];
+  _virtualImmediateQueue = [];
+  _nextImmediateId = 1;
+  _cancelledImmediates = /* @__PURE__ */ new Set();
+  /**
+   * Optional hook called after each timer fires (and after microtask flush).
+   * The clock attaches the scheduler here so that advancing time drives I/O.
+   */
+  onTick;
+  constructor(startTime = 0) {
+    this._now = startTime;
+    this._timers = new MinHeap(
+      (a, b) => a.scheduledTime !== b.scheduledTime ? a.scheduledTime - b.scheduledTime : a.id - b.id
+      // FIFO tie-break
+    );
+  }
+  // queries
+  now() {
+    return this._now + this._skew;
+  }
+  pending() {
+    return this._timers.toArray().map((t) => ({ id: t.id, scheduledTime: t.scheduledTime })).sort((a, b) => a.scheduledTime - b.scheduledTime);
+  }
+  // time control
+  /**
+   * Advance the clock by `duration` ms, firing every timer whose
+   * scheduled time falls within `[now, now + duration]` in order.
+   */
+  async advance(duration) {
+    await this.advanceTo(this._now + duration);
+  }
+  /**
+   * Jump to an absolute virtual timestamp, draining timers along the way.
+   */
+  async advanceTo(timestamp) {
+    if (this._frozen) return;
+    if (timestamp < this._now) return;
+    while (this._timers.size > 0) {
+      const next = this._timers.peek();
+      if (next.scheduledTime > timestamp) break;
+      if (this._cancelledIds.has(next.id)) {
+        this._timers.pop();
+        this._cancelledIds.delete(next.id);
+        continue;
+      }
+      this._timers.pop();
+      if (this._cancelledIds.has(next.id)) {
+        this._cancelledIds.delete(next.id);
+        continue;
+      }
+      this._now = next.scheduledTime;
+      try {
+        const maybePromise = next.callback(...next.args);
+        await this._flushMicrotasks();
+        if (maybePromise instanceof Promise) await maybePromise;
+      } catch (err) {
+        throw new Error(`VirtualClock timer callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+      }
+      await this._flushMicrotasks();
+      if (this.onTick) {
+        await this.onTick(this._now + this._skew);
+        await this._flushMicrotasks();
+      }
+      if (next.interval !== void 0 && !this._cancelledIds.has(next.id)) {
+        this._timers.push({
+          ...next,
+          scheduledTime: next.scheduledTime + next.interval
+        });
+      }
+      this._cancelledIds.delete(next.id);
+      await this._flushImmediates();
+    }
+    this._now = timestamp;
+    await this._flushMicrotasks();
+    if (this.onTick) {
+      await this.onTick(this._now + this._skew);
+      await this._flushMicrotasks();
+    }
+    await this._flushImmediates();
+  }
+  async _flushMicrotasks() {
+    let draining = true;
+    while (draining) {
+      while (this._virtualNextTickQueue.length > 0) {
+        const cb = this._virtualNextTickQueue.shift();
+        try {
+          cb();
+        } catch (err) {
+          throw new Error(`VirtualClock nextTick failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+      }
+      await Promise.resolve();
+      if (this._virtualNextTickQueue.length === 0) {
+        draining = false;
+      }
+    }
+  }
+  async _flushImmediates() {
+    const immediates = [...this._virtualImmediateQueue];
+    this._virtualImmediateQueue.length = 0;
+    for (const imm of immediates) {
+      if (this._cancelledImmediates.has(imm.id)) {
+        this._cancelledImmediates.delete(imm.id);
+        continue;
+      }
+      try {
+        await Promise.resolve(imm.callback(...imm.args));
+      } catch (err) {
+        throw new Error(`VirtualClock immediate failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+      }
+      await this._flushMicrotasks();
+      this._cancelledImmediates.delete(imm.id);
+    }
+  }
+  freeze() {
+    this._frozen = true;
+  }
+  unfreeze() {
+    this._frozen = false;
+  }
+  /**
+   * Apply a clock skew offset (ms). Does NOT fire timers.
+   * `now()` returns `_now + _skew`.
+   */
+  skew(amount) {
+    this._skew += amount;
+  }
+  // timer primitives
+  setTimeout(callback, delay = 0, ...args) {
+    const id = this._nextId++;
+    this._timers.push({
+      id,
+      callback,
+      scheduledTime: this._now + Math.max(0, delay),
+      args
+    });
+    return id;
+  }
+  setInterval(callback, delay, ...args) {
+    const id = this._nextId++;
+    this._timers.push({
+      id,
+      callback,
+      scheduledTime: this._now + Math.max(0, delay),
+      interval: Math.max(1, delay),
+      args
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this._cancelledIds.add(id);
+    this._timers.remove((t) => t.id === id);
+  }
+  clearInterval(id) {
+    this._cancelledIds.add(id);
+    this._timers.remove((t) => t.id === id);
+  }
+  setImmediate(callback, ...args) {
+    const id = this._nextImmediateId++;
+    this._virtualImmediateQueue.push({ id, callback, args });
+    return id;
+  }
+  clearImmediate(id) {
+    this._cancelledImmediates.add(id);
+  }
+  nextTick(callback, ...args) {
+    this._virtualNextTickQueue.push(() => callback(...args));
+  }
+  // lifecycle
+  reset(startTime = 0) {
+    this._now = startTime;
+    this._skew = 0;
+    this._nextId = 1;
+    this._frozen = false;
+    this._timers = new MinHeap(
+      (a, b) => a.scheduledTime !== b.scheduledTime ? a.scheduledTime - b.scheduledTime : a.id - b.id
+    );
+    this._cancelledIds.clear();
+    this._virtualNextTickQueue.length = 0;
+    this._virtualImmediateQueue.length = 0;
+    this._cancelledImmediates.clear();
+    this._nextImmediateId = 1;
+    this.onTick = void 0;
+  }
+};
+
+// src/VirtualDate.ts
+function createVirtualDate(clock) {
+  const OrigDate = Date;
+  class VirtualDate extends OrigDate {
+    constructor(...args) {
+      if (args.length === 0) {
+        super(clock.now());
+      } else if (args.length === 1) {
+        super(args[0]);
+      } else {
+        const tmp = new OrigDate(
+          args[0],
+          args[1] ?? 0,
+          args[2] ?? 1,
+          args[3] ?? 0,
+          args[4] ?? 0,
+          args[5] ?? 0,
+          args[6] ?? 0
+        );
+        super(tmp.getTime());
+      }
+    }
+    static now() {
+      return clock.now();
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance instanceof OrigDate;
+    }
+  }
+  return VirtualDate;
+}
+
+// src/install.ts
+function install(clockOrStart, opts) {
+  const clock = clockOrStart instanceof VirtualClock ? clockOrStart : new VirtualClock(clockOrStart);
+  const originals = {
+    Date: globalThis.Date,
+    setTimeout: globalThis.setTimeout,
+    clearTimeout: globalThis.clearTimeout,
+    setInterval: globalThis.setInterval,
+    clearInterval: globalThis.clearInterval,
+    setImmediate: globalThis.setImmediate,
+    clearImmediate: globalThis.clearImmediate,
+    nextTick: globalThis.process?.nextTick,
+    performanceNow: globalThis.performance.now.bind(globalThis.performance)
+  };
+  globalThis.Date = createVirtualDate(clock);
+  globalThis.setTimeout = (cb, delay, ...args) => clock.setTimeout(cb, delay ?? 0, ...args);
+  globalThis.clearTimeout = (id) => clock.clearTimeout(id);
+  globalThis.setInterval = (cb, delay, ...args) => clock.setInterval(cb, delay, ...args);
+  globalThis.clearInterval = (id) => clock.clearInterval(id);
+  if (typeof globalThis.setImmediate !== "undefined") {
+    globalThis.setImmediate = (cb, ...args) => clock.setImmediate(cb, ...args);
+    globalThis.clearImmediate = (id) => clock.clearImmediate(id);
+  }
+  if (opts?.patchNextTick !== false && globalThis.process && typeof globalThis.process.nextTick === "function") {
+    globalThis.process.nextTick = (cb, ...args) => clock.nextTick(cb, ...args);
+  }
+  globalThis.performance.now = () => clock.now();
+  function uninstall() {
+    globalThis.Date = originals.Date;
+    globalThis.setTimeout = originals.setTimeout;
+    globalThis.clearTimeout = originals.clearTimeout;
+    globalThis.setInterval = originals.setInterval;
+    globalThis.clearInterval = originals.clearInterval;
+    if (originals.setImmediate) globalThis.setImmediate = originals.setImmediate;
+    if (originals.clearImmediate) globalThis.clearImmediate = originals.clearImmediate;
+    if (originals.nextTick && globalThis.process) globalThis.process.nextTick = originals.nextTick;
+    globalThis.performance.now = originals.performanceNow;
+  }
+  return { clock, uninstall };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MinHeap,
+  VirtualClock,
+  createVirtualDate,
+  install
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/MinHeap.ts","../src/VirtualClock.ts","../src/VirtualDate.ts","../src/install.ts"],"sourcesContent":["export { VirtualClock } from './VirtualClock.js';\nexport { createVirtualDate } from './VirtualDate.js';\nexport { install } from './install.js';\nexport type { ClockInstallResult, ClockInstallOptions } from './install.js';\nexport type { TimerEntry } from './VirtualClock.js';\nexport { MinHeap } from './MinHeap.js';\n","/**\n * Generic min-heap priority queue.\n * O(log n) push/pop, used as the timer scheduling backbone.\n */\nexport class MinHeap<T> {\n  private heap: T[] = [];\n\n  constructor(private readonly comparator: (a: T, b: T) => number) {}\n\n  get size(): number {\n    return this.heap.length;\n  }\n\n  peek(): T | undefined {\n    return this.heap[0];\n  }\n\n  push(value: T): void {\n    this.heap.push(value);\n    this.bubbleUp(this.heap.length - 1);\n  }\n\n  pop(): T | undefined {\n    const n = this.heap.length;\n    if (n === 0) return undefined;\n    const top = this.heap[0];\n    const last = this.heap.pop()!;\n    if (this.heap.length > 0) {\n      this.heap[0] = last;\n      this.sinkDown(0);\n    }\n    return top;\n  }\n\n  /** Remove first entry matching predicate. Returns true if found. */\n  remove(predicate: (v: T) => boolean): boolean {\n    const idx = this.heap.findIndex(predicate);\n    if (idx === -1) return false;\n    const last = this.heap.pop()!;\n    if (idx < this.heap.length) {\n      this.heap[idx] = last;\n      this.bubbleUp(idx);\n      this.sinkDown(idx);\n    }\n    return true;\n  }\n\n  toArray(): T[] {\n    return [...this.heap];\n  }\n\n  private bubbleUp(i: number): void {\n    while (i > 0) {\n      const parent = (i - 1) >> 1;\n      if (this.comparator(this.heap[i], this.heap[parent]) >= 0) break;\n      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];\n      i = parent;\n    }\n  }\n\n  private sinkDown(i: number): void {\n    const n = this.heap.length;\n    while (true) {\n      let smallest = i;\n      const left = 2 * i + 1;\n      const right = 2 * i + 2;\n      if (left < n && this.comparator(this.heap[left], this.heap[smallest]) < 0)\n        smallest = left;\n      if (right < n && this.comparator(this.heap[right], this.heap[smallest]) < 0)\n        smallest = right;\n      if (smallest === i) break;\n      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];\n      i = smallest;\n    }\n  }\n}\n","import { MinHeap } from './MinHeap.js';\n\n/** Internal timer entry stored in the heap. */\nexport interface TimerEntry {\n  id: number;\n  callback: (...args: unknown[]) => void | Promise<void>;\n  scheduledTime: number;\n  interval?: number;\n  args: unknown[];\n}\n\n/**\n * A manually-controllable virtual clock.\n *\n * Replaces all time primitives so that `advance(duration)` fires timers\n * deterministically, in scheduled-time order.  Timers that schedule new\n * timers within the same advance window ARE picked up and executed in\n * the correct order (the heap is re-checked after every callback).\n */\nexport class VirtualClock {\n  private _now: number;\n  private _skew: number = 0;\n  private _nextId = 1;\n  private _frozen = false;\n  private _timers: MinHeap<TimerEntry>;\n  private readonly _cancelledIds = new Set<number>();\n\n  private readonly _virtualNextTickQueue: Array<(...args: unknown[]) => void> = [];\n  private readonly _virtualImmediateQueue: Array<{ id: number; callback: (...args: unknown[]) => void | Promise<void>; args: unknown[]; }> = [];\n  private _nextImmediateId = 1;\n  private readonly _cancelledImmediates = new Set<number>();\n\n  /**\n   * Optional hook called after each timer fires (and after microtask flush).\n   * The clock attaches the scheduler here so that advancing time drives I/O.\n   */\n  onTick?: (time: number) => Promise<void>;\n\n  constructor(startTime: number = 0) {\n    this._now = startTime;\n    this._timers = new MinHeap<TimerEntry>((a, b) =>\n      a.scheduledTime !== b.scheduledTime\n        ? a.scheduledTime - b.scheduledTime\n        : a.id - b.id, // FIFO tie-break\n    );\n  }\n\n  // queries\n\n  now(): number {\n    return this._now + this._skew;\n  }\n\n  pending(): Array<{ id: number; scheduledTime: number }> {\n    return this._timers\n      .toArray()\n      .map((t) => ({ id: t.id, scheduledTime: t.scheduledTime }))\n      .sort((a, b) => a.scheduledTime - b.scheduledTime);\n  }\n\n  // time control\n\n  /**\n   * Advance the clock by `duration` ms, firing every timer whose\n   * scheduled time falls within `[now, now + duration]` in order.\n   */\n  async advance(duration: number): Promise<void> {\n    await this.advanceTo(this._now + duration);\n  }\n\n  /**\n   * Jump to an absolute virtual timestamp, draining timers along the way.\n   */\n  async advanceTo(timestamp: number): Promise<void> {\n    if (this._frozen) return;\n    if (timestamp < this._now) return; // never go backward\n\n    while (this._timers.size > 0) {\n      const next = this._timers.peek()!;\n      if (next.scheduledTime > timestamp) break;\n\n      // If cancelled while it was in queue\n      if (this._cancelledIds.has(next.id)) {\n        this._timers.pop();\n        this._cancelledIds.delete(next.id);\n        continue;\n      }\n\n      // Pop right before execution\n      this._timers.pop();\n      if (this._cancelledIds.has(next.id)) {\n         this._cancelledIds.delete(next.id);\n         continue;\n      }\n\n      this._now = next.scheduledTime;\n\n      try {\n        // Call synchronously first so that process.nextTick callbacks\n        // registered inside the timer run before native Promise microtasks.\n        // If the callback is async, await its returned Promise afterward.\n        const maybePromise = next.callback(...next.args);\n        await this._flushMicrotasks();\n        if (maybePromise instanceof Promise) await maybePromise;\n      } catch (err) {\n        throw new Error(`VirtualClock timer callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n      }\n\n      await this._flushMicrotasks();\n\n      // Call onTick hook so the scheduler can run I/O completions for this tick\n      if (this.onTick) {\n        await this.onTick(this._now + this._skew);\n        await this._flushMicrotasks();\n      }\n\n      // If this was an interval AND not cancelled during the callback or microtasks,\n      // reschedule for the next tick.\n      if (next.interval !== undefined && !this._cancelledIds.has(next.id)) {\n        this._timers.push({\n          ...next,\n          scheduledTime: next.scheduledTime + next.interval,\n        });\n      }\n      this._cancelledIds.delete(next.id);\n\n      await this._flushImmediates();\n    }\n    this._now = timestamp;\n\n    // End of advance flush\n    await this._flushMicrotasks();\n    if (this.onTick) {\n      await this.onTick(this._now + this._skew);\n      await this._flushMicrotasks();\n    }\n    await this._flushImmediates();\n  }\n\n  private async _flushMicrotasks(): Promise<void> {\n    let draining = true;\n    while (draining) {\n      // Phase 1: drain the virtual nextTick queue synchronously (nextTick runs before native microtasks)\n      while (this._virtualNextTickQueue.length > 0) {\n        const cb = this._virtualNextTickQueue.shift()!;\n        try {\n          cb();\n        } catch (err) {\n          throw new Error(`VirtualClock nextTick failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n        }\n      }\n      // Phase 2: one V8 microtask checkpoint (lets native Promise chains resolve)\n      await Promise.resolve();\n      // Phase 3: if new nextTick callbacks were enqueued by those microtasks, loop again;\n      // otherwise we're stable.\n      if (this._virtualNextTickQueue.length === 0) {\n        draining = false;\n      }\n    }\n  }\n\n  private async _flushImmediates(): Promise<void> {\n    const immediates = [...this._virtualImmediateQueue];\n    this._virtualImmediateQueue.length = 0;\n\n    for (const imm of immediates) {\n      if (this._cancelledImmediates.has(imm.id)) {\n        this._cancelledImmediates.delete(imm.id);\n        continue;\n      }\n      try {\n        await Promise.resolve(imm.callback(...imm.args));\n      } catch (err) {\n        throw new Error(`VirtualClock immediate failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n      }\n      await this._flushMicrotasks();\n      this._cancelledImmediates.delete(imm.id);\n    }\n  }\n\n  freeze(): void {\n    this._frozen = true;\n  }\n\n  unfreeze(): void {\n    this._frozen = false;\n  }\n\n  /**\n   * Apply a clock skew offset (ms). Does NOT fire timers.\n   * `now()` returns `_now + _skew`.\n   */\n  skew(amount: number): void {\n    this._skew += amount;\n  }\n\n  // timer primitives\n\n  setTimeout(\n    callback: (...args: unknown[]) => void | Promise<void>,\n    delay: number = 0,\n    ...args: unknown[]\n  ): number {\n    const id = this._nextId++;\n    this._timers.push({\n      id,\n      callback,\n      scheduledTime: this._now + Math.max(0, delay),\n      args,\n    });\n    return id;\n  }\n\n  setInterval(\n    callback: (...args: unknown[]) => void | Promise<void>,\n    delay: number,\n    ...args: unknown[]\n  ): number {\n    const id = this._nextId++;\n    this._timers.push({\n      id,\n      callback,\n      scheduledTime: this._now + Math.max(0, delay),\n      interval: Math.max(1, delay),\n      args,\n    });\n    return id;\n  }\n\n  clearTimeout(id: number): void {\n    this._cancelledIds.add(id);\n    this._timers.remove((t) => t.id === id);\n  }\n\n  clearInterval(id: number): void {\n    this._cancelledIds.add(id);\n    this._timers.remove((t) => t.id === id);\n  }\n\n  setImmediate(callback: (...args: unknown[]) => void | Promise<void>, ...args: unknown[]): number {\n    const id = this._nextImmediateId++;\n    this._virtualImmediateQueue.push({ id, callback, args });\n    return id;\n  }\n\n  clearImmediate(id: number): void {\n    this._cancelledImmediates.add(id);\n  }\n\n  nextTick(callback: (...args: unknown[]) => void, ...args: unknown[]): void {\n    this._virtualNextTickQueue.push(() => callback(...args));\n  }\n\n  // lifecycle\n\n  reset(startTime: number = 0): void {\n    this._now = startTime;\n    this._skew = 0;\n    this._nextId = 1;\n    this._frozen = false;\n    this._timers = new MinHeap<TimerEntry>((a, b) =>\n      a.scheduledTime !== b.scheduledTime\n        ? a.scheduledTime - b.scheduledTime\n        : a.id - b.id,\n    );\n    this._cancelledIds.clear();\n    this._virtualNextTickQueue.length = 0;\n    this._virtualImmediateQueue.length = 0;\n    this._cancelledImmediates.clear();\n    this._nextImmediateId = 1;\n    this.onTick = undefined;\n  }\n}\n","import type { VirtualClock } from './VirtualClock.js';\n\n/**\n * Build a `DateConstructor` whose `now()` and zero-arg `new Date()`\n * read from the supplied VirtualClock.\n */\nexport function createVirtualDate(clock: VirtualClock): DateConstructor {\n  const OrigDate = Date;\n\n  class VirtualDate extends OrigDate {\n    constructor(...args: unknown[]) {\n      if (args.length === 0) {\n        super(clock.now());\n      } else if (args.length === 1) {\n        super(args[0] as string | number);\n      } else {\n        // Multi-arg (year, month, …): delegate to native Date for\n        // local-time semantics, then feed the resulting timestamp to super.\n        const tmp = new OrigDate(\n          args[0] as number,\n          (args[1] as number) ?? 0,\n          (args[2] as number) ?? 1,\n          (args[3] as number) ?? 0,\n          (args[4] as number) ?? 0,\n          (args[5] as number) ?? 0,\n          (args[6] as number) ?? 0,\n        );\n        super(tmp.getTime());\n      }\n    }\n\n    static override now(): number {\n      return clock.now();\n    }\n\n    static [Symbol.hasInstance](instance: unknown): boolean {\n      return instance instanceof OrigDate;\n    }\n  }\n\n  return VirtualDate as unknown as DateConstructor;\n}\n","import { VirtualClock } from './VirtualClock.js';\nimport { createVirtualDate } from './VirtualDate.js';\n\nexport interface ClockInstallResult {\n  clock: VirtualClock;\n  uninstall: () => void;\n}\n\nexport interface ClockInstallOptions {\n  /**\n   * If true (the default), patch `process.nextTick` to route through the virtual clock.\n   * This ensures deterministic ordering of nextTick callbacks relative to timers.\n   *\n   * Set to false only when your scenario uses dynamic `import()`, undici, or other\n   * Node.js internals that rely on `process.nextTick` for initialization, and those\n   * operations run outside of any `advance()` call (which would otherwise drain the\n   * virtual nextTick queue via `_flushMicrotasks`).\n   *\n   * @default true\n   */\n  patchNextTick?: boolean;\n}\n\n/**\n * Patch all global time primitives to use a VirtualClock.\n *\n * Returns the clock instance and an `uninstall` function that restores\n * every original global.\n */\nexport function install(clockOrStart?: VirtualClock | number, opts?: ClockInstallOptions): ClockInstallResult {\n  const clock =\n    clockOrStart instanceof VirtualClock\n      ? clockOrStart\n      : new VirtualClock(clockOrStart);\n\n  const originals = {\n    Date: globalThis.Date,\n    setTimeout: globalThis.setTimeout,\n    clearTimeout: globalThis.clearTimeout,\n    setInterval: globalThis.setInterval,\n    clearInterval: globalThis.clearInterval,\n    setImmediate: globalThis.setImmediate,\n    clearImmediate: globalThis.clearImmediate,\n    nextTick: globalThis.process?.nextTick,\n    performanceNow: globalThis.performance.now.bind(globalThis.performance),\n  };\n\n  globalThis.Date = createVirtualDate(clock);\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  (globalThis as any).setTimeout = (\n    cb: (...a: unknown[]) => void,\n    delay?: number,\n    ...args: unknown[]\n  ) => clock.setTimeout(cb, delay ?? 0, ...args);\n\n  (globalThis as any).clearTimeout = (id: number) => clock.clearTimeout(id);\n\n  (globalThis as any).setInterval = (\n    cb: (...a: unknown[]) => void,\n    delay: number,\n    ...args: unknown[]\n  ) => clock.setInterval(cb, delay, ...args);\n\n  (globalThis as any).clearInterval = (id: number) => clock.clearInterval(id);\n\n  if (typeof globalThis.setImmediate !== 'undefined') {\n    (globalThis as any).setImmediate = (cb: (...a: unknown[]) => void, ...args: unknown[]) => clock.setImmediate(cb, ...args);\n    (globalThis as any).clearImmediate = (id: number) => clock.clearImmediate(id);\n  }\n\n  if (opts?.patchNextTick !== false && globalThis.process && typeof globalThis.process.nextTick === 'function') {\n    globalThis.process.nextTick = (cb: (...a: unknown[]) => void, ...args: unknown[]) => clock.nextTick(cb, ...args);\n  }\n\n  globalThis.performance.now = () => clock.now();\n\n  function uninstall(): void {\n    globalThis.Date = originals.Date;\n    globalThis.setTimeout = originals.setTimeout;\n    globalThis.clearTimeout = originals.clearTimeout;\n    globalThis.setInterval = originals.setInterval;\n    globalThis.clearInterval = originals.clearInterval;\n    if (originals.setImmediate) globalThis.setImmediate = originals.setImmediate;\n    if (originals.clearImmediate) globalThis.clearImmediate = originals.clearImmediate;\n    if (originals.nextTick && globalThis.process) globalThis.process.nextTick = originals.nextTick;\n    globalThis.performance.now = originals.performanceNow;\n  }\n\n  return { clock, uninstall };\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { VirtualClock } from './VirtualClock.js';
+export { createVirtualDate } from './VirtualDate.js';
+export { install } from './install.js';
+export type { ClockInstallResult, ClockInstallOptions } from './install.js';
+export type { TimerEntry } from './VirtualClock.js';
+export { MinHeap } from './MinHeap.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,340 @@
+// src/MinHeap.ts
+var MinHeap = class {
+  constructor(comparator) {
+    this.comparator = comparator;
+  }
+  heap = [];
+  get size() {
+    return this.heap.length;
+  }
+  peek() {
+    return this.heap[0];
+  }
+  push(value) {
+    this.heap.push(value);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  pop() {
+    const n = this.heap.length;
+    if (n === 0) return void 0;
+    const top = this.heap[0];
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return top;
+  }
+  /** Remove first entry matching predicate. Returns true if found. */
+  remove(predicate) {
+    const idx = this.heap.findIndex(predicate);
+    if (idx === -1) return false;
+    const last = this.heap.pop();
+    if (idx < this.heap.length) {
+      this.heap[idx] = last;
+      this.bubbleUp(idx);
+      this.sinkDown(idx);
+    }
+    return true;
+  }
+  toArray() {
+    return [...this.heap];
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.comparator(this.heap[i], this.heap[parent]) >= 0) break;
+      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];
+      i = parent;
+    }
+  }
+  sinkDown(i) {
+    const n = this.heap.length;
+    while (true) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < n && this.comparator(this.heap[left], this.heap[smallest]) < 0)
+        smallest = left;
+      if (right < n && this.comparator(this.heap[right], this.heap[smallest]) < 0)
+        smallest = right;
+      if (smallest === i) break;
+      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];
+      i = smallest;
+    }
+  }
+};
+
+// src/VirtualClock.ts
+var VirtualClock = class {
+  _now;
+  _skew = 0;
+  _nextId = 1;
+  _frozen = false;
+  _timers;
+  _cancelledIds = /* @__PURE__ */ new Set();
+  _virtualNextTickQueue = [];
+  _virtualImmediateQueue = [];
+  _nextImmediateId = 1;
+  _cancelledImmediates = /* @__PURE__ */ new Set();
+  /**
+   * Optional hook called after each timer fires (and after microtask flush).
+   * The clock attaches the scheduler here so that advancing time drives I/O.
+   */
+  onTick;
+  constructor(startTime = 0) {
+    this._now = startTime;
+    this._timers = new MinHeap(
+      (a, b) => a.scheduledTime !== b.scheduledTime ? a.scheduledTime - b.scheduledTime : a.id - b.id
+      // FIFO tie-break
+    );
+  }
+  // queries
+  now() {
+    return this._now + this._skew;
+  }
+  pending() {
+    return this._timers.toArray().map((t) => ({ id: t.id, scheduledTime: t.scheduledTime })).sort((a, b) => a.scheduledTime - b.scheduledTime);
+  }
+  // time control
+  /**
+   * Advance the clock by `duration` ms, firing every timer whose
+   * scheduled time falls within `[now, now + duration]` in order.
+   */
+  async advance(duration) {
+    await this.advanceTo(this._now + duration);
+  }
+  /**
+   * Jump to an absolute virtual timestamp, draining timers along the way.
+   */
+  async advanceTo(timestamp) {
+    if (this._frozen) return;
+    if (timestamp < this._now) return;
+    while (this._timers.size > 0) {
+      const next = this._timers.peek();
+      if (next.scheduledTime > timestamp) break;
+      if (this._cancelledIds.has(next.id)) {
+        this._timers.pop();
+        this._cancelledIds.delete(next.id);
+        continue;
+      }
+      this._timers.pop();
+      if (this._cancelledIds.has(next.id)) {
+        this._cancelledIds.delete(next.id);
+        continue;
+      }
+      this._now = next.scheduledTime;
+      try {
+        const maybePromise = next.callback(...next.args);
+        await this._flushMicrotasks();
+        if (maybePromise instanceof Promise) await maybePromise;
+      } catch (err) {
+        throw new Error(`VirtualClock timer callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+      }
+      await this._flushMicrotasks();
+      if (this.onTick) {
+        await this.onTick(this._now + this._skew);
+        await this._flushMicrotasks();
+      }
+      if (next.interval !== void 0 && !this._cancelledIds.has(next.id)) {
+        this._timers.push({
+          ...next,
+          scheduledTime: next.scheduledTime + next.interval
+        });
+      }
+      this._cancelledIds.delete(next.id);
+      await this._flushImmediates();
+    }
+    this._now = timestamp;
+    await this._flushMicrotasks();
+    if (this.onTick) {
+      await this.onTick(this._now + this._skew);
+      await this._flushMicrotasks();
+    }
+    await this._flushImmediates();
+  }
+  async _flushMicrotasks() {
+    let draining = true;
+    while (draining) {
+      while (this._virtualNextTickQueue.length > 0) {
+        const cb = this._virtualNextTickQueue.shift();
+        try {
+          cb();
+        } catch (err) {
+          throw new Error(`VirtualClock nextTick failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+      }
+      await Promise.resolve();
+      if (this._virtualNextTickQueue.length === 0) {
+        draining = false;
+      }
+    }
+  }
+  async _flushImmediates() {
+    const immediates = [...this._virtualImmediateQueue];
+    this._virtualImmediateQueue.length = 0;
+    for (const imm of immediates) {
+      if (this._cancelledImmediates.has(imm.id)) {
+        this._cancelledImmediates.delete(imm.id);
+        continue;
+      }
+      try {
+        await Promise.resolve(imm.callback(...imm.args));
+      } catch (err) {
+        throw new Error(`VirtualClock immediate failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+      }
+      await this._flushMicrotasks();
+      this._cancelledImmediates.delete(imm.id);
+    }
+  }
+  freeze() {
+    this._frozen = true;
+  }
+  unfreeze() {
+    this._frozen = false;
+  }
+  /**
+   * Apply a clock skew offset (ms). Does NOT fire timers.
+   * `now()` returns `_now + _skew`.
+   */
+  skew(amount) {
+    this._skew += amount;
+  }
+  // timer primitives
+  setTimeout(callback, delay = 0, ...args) {
+    const id = this._nextId++;
+    this._timers.push({
+      id,
+      callback,
+      scheduledTime: this._now + Math.max(0, delay),
+      args
+    });
+    return id;
+  }
+  setInterval(callback, delay, ...args) {
+    const id = this._nextId++;
+    this._timers.push({
+      id,
+      callback,
+      scheduledTime: this._now + Math.max(0, delay),
+      interval: Math.max(1, delay),
+      args
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this._cancelledIds.add(id);
+    this._timers.remove((t) => t.id === id);
+  }
+  clearInterval(id) {
+    this._cancelledIds.add(id);
+    this._timers.remove((t) => t.id === id);
+  }
+  setImmediate(callback, ...args) {
+    const id = this._nextImmediateId++;
+    this._virtualImmediateQueue.push({ id, callback, args });
+    return id;
+  }
+  clearImmediate(id) {
+    this._cancelledImmediates.add(id);
+  }
+  nextTick(callback, ...args) {
+    this._virtualNextTickQueue.push(() => callback(...args));
+  }
+  // lifecycle
+  reset(startTime = 0) {
+    this._now = startTime;
+    this._skew = 0;
+    this._nextId = 1;
+    this._frozen = false;
+    this._timers = new MinHeap(
+      (a, b) => a.scheduledTime !== b.scheduledTime ? a.scheduledTime - b.scheduledTime : a.id - b.id
+    );
+    this._cancelledIds.clear();
+    this._virtualNextTickQueue.length = 0;
+    this._virtualImmediateQueue.length = 0;
+    this._cancelledImmediates.clear();
+    this._nextImmediateId = 1;
+    this.onTick = void 0;
+  }
+};
+
+// src/VirtualDate.ts
+function createVirtualDate(clock) {
+  const OrigDate = Date;
+  class VirtualDate extends OrigDate {
+    constructor(...args) {
+      if (args.length === 0) {
+        super(clock.now());
+      } else if (args.length === 1) {
+        super(args[0]);
+      } else {
+        const tmp = new OrigDate(
+          args[0],
+          args[1] ?? 0,
+          args[2] ?? 1,
+          args[3] ?? 0,
+          args[4] ?? 0,
+          args[5] ?? 0,
+          args[6] ?? 0
+        );
+        super(tmp.getTime());
+      }
+    }
+    static now() {
+      return clock.now();
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance instanceof OrigDate;
+    }
+  }
+  return VirtualDate;
+}
+
+// src/install.ts
+function install(clockOrStart, opts) {
+  const clock = clockOrStart instanceof VirtualClock ? clockOrStart : new VirtualClock(clockOrStart);
+  const originals = {
+    Date: globalThis.Date,
+    setTimeout: globalThis.setTimeout,
+    clearTimeout: globalThis.clearTimeout,
+    setInterval: globalThis.setInterval,
+    clearInterval: globalThis.clearInterval,
+    setImmediate: globalThis.setImmediate,
+    clearImmediate: globalThis.clearImmediate,
+    nextTick: globalThis.process?.nextTick,
+    performanceNow: globalThis.performance.now.bind(globalThis.performance)
+  };
+  globalThis.Date = createVirtualDate(clock);
+  globalThis.setTimeout = (cb, delay, ...args) => clock.setTimeout(cb, delay ?? 0, ...args);
+  globalThis.clearTimeout = (id) => clock.clearTimeout(id);
+  globalThis.setInterval = (cb, delay, ...args) => clock.setInterval(cb, delay, ...args);
+  globalThis.clearInterval = (id) => clock.clearInterval(id);
+  if (typeof globalThis.setImmediate !== "undefined") {
+    globalThis.setImmediate = (cb, ...args) => clock.setImmediate(cb, ...args);
+    globalThis.clearImmediate = (id) => clock.clearImmediate(id);
+  }
+  if (opts?.patchNextTick !== false && globalThis.process && typeof globalThis.process.nextTick === "function") {
+    globalThis.process.nextTick = (cb, ...args) => clock.nextTick(cb, ...args);
+  }
+  globalThis.performance.now = () => clock.now();
+  function uninstall() {
+    globalThis.Date = originals.Date;
+    globalThis.setTimeout = originals.setTimeout;
+    globalThis.clearTimeout = originals.clearTimeout;
+    globalThis.setInterval = originals.setInterval;
+    globalThis.clearInterval = originals.clearInterval;
+    if (originals.setImmediate) globalThis.setImmediate = originals.setImmediate;
+    if (originals.clearImmediate) globalThis.clearImmediate = originals.clearImmediate;
+    if (originals.nextTick && globalThis.process) globalThis.process.nextTick = originals.nextTick;
+    globalThis.performance.now = originals.performanceNow;
+  }
+  return { clock, uninstall };
+}
+export {
+  MinHeap,
+  VirtualClock,
+  createVirtualDate,
+  install
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/MinHeap.ts","../src/VirtualClock.ts","../src/VirtualDate.ts","../src/install.ts"],"sourcesContent":["/**\n * Generic min-heap priority queue.\n * O(log n) push/pop, used as the timer scheduling backbone.\n */\nexport class MinHeap<T> {\n  private heap: T[] = [];\n\n  constructor(private readonly comparator: (a: T, b: T) => number) {}\n\n  get size(): number {\n    return this.heap.length;\n  }\n\n  peek(): T | undefined {\n    return this.heap[0];\n  }\n\n  push(value: T): void {\n    this.heap.push(value);\n    this.bubbleUp(this.heap.length - 1);\n  }\n\n  pop(): T | undefined {\n    const n = this.heap.length;\n    if (n === 0) return undefined;\n    const top = this.heap[0];\n    const last = this.heap.pop()!;\n    if (this.heap.length > 0) {\n      this.heap[0] = last;\n      this.sinkDown(0);\n    }\n    return top;\n  }\n\n  /** Remove first entry matching predicate. Returns true if found. */\n  remove(predicate: (v: T) => boolean): boolean {\n    const idx = this.heap.findIndex(predicate);\n    if (idx === -1) return false;\n    const last = this.heap.pop()!;\n    if (idx < this.heap.length) {\n      this.heap[idx] = last;\n      this.bubbleUp(idx);\n      this.sinkDown(idx);\n    }\n    return true;\n  }\n\n  toArray(): T[] {\n    return [...this.heap];\n  }\n\n  private bubbleUp(i: number): void {\n    while (i > 0) {\n      const parent = (i - 1) >> 1;\n      if (this.comparator(this.heap[i], this.heap[parent]) >= 0) break;\n      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];\n      i = parent;\n    }\n  }\n\n  private sinkDown(i: number): void {\n    const n = this.heap.length;\n    while (true) {\n      let smallest = i;\n      const left = 2 * i + 1;\n      const right = 2 * i + 2;\n      if (left < n && this.comparator(this.heap[left], this.heap[smallest]) < 0)\n        smallest = left;\n      if (right < n && this.comparator(this.heap[right], this.heap[smallest]) < 0)\n        smallest = right;\n      if (smallest === i) break;\n      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];\n      i = smallest;\n    }\n  }\n}\n","import { MinHeap } from './MinHeap.js';\n\n/** Internal timer entry stored in the heap. */\nexport interface TimerEntry {\n  id: number;\n  callback: (...args: unknown[]) => void | Promise<void>;\n  scheduledTime: number;\n  interval?: number;\n  args: unknown[];\n}\n\n/**\n * A manually-controllable virtual clock.\n *\n * Replaces all time primitives so that `advance(duration)` fires timers\n * deterministically, in scheduled-time order.  Timers that schedule new\n * timers within the same advance window ARE picked up and executed in\n * the correct order (the heap is re-checked after every callback).\n */\nexport class VirtualClock {\n  private _now: number;\n  private _skew: number = 0;\n  private _nextId = 1;\n  private _frozen = false;\n  private _timers: MinHeap<TimerEntry>;\n  private readonly _cancelledIds = new Set<number>();\n\n  private readonly _virtualNextTickQueue: Array<(...args: unknown[]) => void> = [];\n  private readonly _virtualImmediateQueue: Array<{ id: number; callback: (...args: unknown[]) => void | Promise<void>; args: unknown[]; }> = [];\n  private _nextImmediateId = 1;\n  private readonly _cancelledImmediates = new Set<number>();\n\n  /**\n   * Optional hook called after each timer fires (and after microtask flush).\n   * The clock attaches the scheduler here so that advancing time drives I/O.\n   */\n  onTick?: (time: number) => Promise<void>;\n\n  constructor(startTime: number = 0) {\n    this._now = startTime;\n    this._timers = new MinHeap<TimerEntry>((a, b) =>\n      a.scheduledTime !== b.scheduledTime\n        ? a.scheduledTime - b.scheduledTime\n        : a.id - b.id, // FIFO tie-break\n    );\n  }\n\n  // queries\n\n  now(): number {\n    return this._now + this._skew;\n  }\n\n  pending(): Array<{ id: number; scheduledTime: number }> {\n    return this._timers\n      .toArray()\n      .map((t) => ({ id: t.id, scheduledTime: t.scheduledTime }))\n      .sort((a, b) => a.scheduledTime - b.scheduledTime);\n  }\n\n  // time control\n\n  /**\n   * Advance the clock by `duration` ms, firing every timer whose\n   * scheduled time falls within `[now, now + duration]` in order.\n   */\n  async advance(duration: number): Promise<void> {\n    await this.advanceTo(this._now + duration);\n  }\n\n  /**\n   * Jump to an absolute virtual timestamp, draining timers along the way.\n   */\n  async advanceTo(timestamp: number): Promise<void> {\n    if (this._frozen) return;\n    if (timestamp < this._now) return; // never go backward\n\n    while (this._timers.size > 0) {\n      const next = this._timers.peek()!;\n      if (next.scheduledTime > timestamp) break;\n\n      // If cancelled while it was in queue\n      if (this._cancelledIds.has(next.id)) {\n        this._timers.pop();\n        this._cancelledIds.delete(next.id);\n        continue;\n      }\n\n      // Pop right before execution\n      this._timers.pop();\n      if (this._cancelledIds.has(next.id)) {\n         this._cancelledIds.delete(next.id);\n         continue;\n      }\n\n      this._now = next.scheduledTime;\n\n      try {\n        // Call synchronously first so that process.nextTick callbacks\n        // registered inside the timer run before native Promise microtasks.\n        // If the callback is async, await its returned Promise afterward.\n        const maybePromise = next.callback(...next.args);\n        await this._flushMicrotasks();\n        if (maybePromise instanceof Promise) await maybePromise;\n      } catch (err) {\n        throw new Error(`VirtualClock timer callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n      }\n\n      await this._flushMicrotasks();\n\n      // Call onTick hook so the scheduler can run I/O completions for this tick\n      if (this.onTick) {\n        await this.onTick(this._now + this._skew);\n        await this._flushMicrotasks();\n      }\n\n      // If this was an interval AND not cancelled during the callback or microtasks,\n      // reschedule for the next tick.\n      if (next.interval !== undefined && !this._cancelledIds.has(next.id)) {\n        this._timers.push({\n          ...next,\n          scheduledTime: next.scheduledTime + next.interval,\n        });\n      }\n      this._cancelledIds.delete(next.id);\n\n      await this._flushImmediates();\n    }\n    this._now = timestamp;\n\n    // End of advance flush\n    await this._flushMicrotasks();\n    if (this.onTick) {\n      await this.onTick(this._now + this._skew);\n      await this._flushMicrotasks();\n    }\n    await this._flushImmediates();\n  }\n\n  private async _flushMicrotasks(): Promise<void> {\n    let draining = true;\n    while (draining) {\n      // Phase 1: drain the virtual nextTick queue synchronously (nextTick runs before native microtasks)\n      while (this._virtualNextTickQueue.length > 0) {\n        const cb = this._virtualNextTickQueue.shift()!;\n        try {\n          cb();\n        } catch (err) {\n          throw new Error(`VirtualClock nextTick failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n        }\n      }\n      // Phase 2: one V8 microtask checkpoint (lets native Promise chains resolve)\n      await Promise.resolve();\n      // Phase 3: if new nextTick callbacks were enqueued by those microtasks, loop again;\n      // otherwise we're stable.\n      if (this._virtualNextTickQueue.length === 0) {\n        draining = false;\n      }\n    }\n  }\n\n  private async _flushImmediates(): Promise<void> {\n    const immediates = [...this._virtualImmediateQueue];\n    this._virtualImmediateQueue.length = 0;\n\n    for (const imm of immediates) {\n      if (this._cancelledImmediates.has(imm.id)) {\n        this._cancelledImmediates.delete(imm.id);\n        continue;\n      }\n      try {\n        await Promise.resolve(imm.callback(...imm.args));\n      } catch (err) {\n        throw new Error(`VirtualClock immediate failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });\n      }\n      await this._flushMicrotasks();\n      this._cancelledImmediates.delete(imm.id);\n    }\n  }\n\n  freeze(): void {\n    this._frozen = true;\n  }\n\n  unfreeze(): void {\n    this._frozen = false;\n  }\n\n  /**\n   * Apply a clock skew offset (ms). Does NOT fire timers.\n   * `now()` returns `_now + _skew`.\n   */\n  skew(amount: number): void {\n    this._skew += amount;\n  }\n\n  // timer primitives\n\n  setTimeout(\n    callback: (...args: unknown[]) => void | Promise<void>,\n    delay: number = 0,\n    ...args: unknown[]\n  ): number {\n    const id = this._nextId++;\n    this._timers.push({\n      id,\n      callback,\n      scheduledTime: this._now + Math.max(0, delay),\n      args,\n    });\n    return id;\n  }\n\n  setInterval(\n    callback: (...args: unknown[]) => void | Promise<void>,\n    delay: number,\n    ...args: unknown[]\n  ): number {\n    const id = this._nextId++;\n    this._timers.push({\n      id,\n      callback,\n      scheduledTime: this._now + Math.max(0, delay),\n      interval: Math.max(1, delay),\n      args,\n    });\n    return id;\n  }\n\n  clearTimeout(id: number): void {\n    this._cancelledIds.add(id);\n    this._timers.remove((t) => t.id === id);\n  }\n\n  clearInterval(id: number): void {\n    this._cancelledIds.add(id);\n    this._timers.remove((t) => t.id === id);\n  }\n\n  setImmediate(callback: (...args: unknown[]) => void | Promise<void>, ...args: unknown[]): number {\n    const id = this._nextImmediateId++;\n    this._virtualImmediateQueue.push({ id, callback, args });\n    return id;\n  }\n\n  clearImmediate(id: number): void {\n    this._cancelledImmediates.add(id);\n  }\n\n  nextTick(callback: (...args: unknown[]) => void, ...args: unknown[]): void {\n    this._virtualNextTickQueue.push(() => callback(...args));\n  }\n\n  // lifecycle\n\n  reset(startTime: number = 0): void {\n    this._now = startTime;\n    this._skew = 0;\n    this._nextId = 1;\n    this._frozen = false;\n    this._timers = new MinHeap<TimerEntry>((a, b) =>\n      a.scheduledTime !== b.scheduledTime\n        ? a.scheduledTime - b.scheduledTime\n        : a.id - b.id,\n    );\n    this._cancelledIds.clear();\n    this._virtualNextTickQueue.length = 0;\n    this._virtualImmediateQueue.length = 0;\n    this._cancelledImmediates.clear();\n    this._nextImmediateId = 1;\n    this.onTick = undefined;\n  }\n}\n","import type { VirtualClock } from './VirtualClock.js';\n\n/**\n * Build a `DateConstructor` whose `now()` and zero-arg `new Date()`\n * read from the supplied VirtualClock.\n */\nexport function createVirtualDate(clock: VirtualClock): DateConstructor {\n  const OrigDate = Date;\n\n  class VirtualDate extends OrigDate {\n    constructor(...args: unknown[]) {\n      if (args.length === 0) {\n        super(clock.now());\n      } else if (args.length === 1) {\n        super(args[0] as string | number);\n      } else {\n        // Multi-arg (year, month, …): delegate to native Date for\n        // local-time semantics, then feed the resulting timestamp to super.\n        const tmp = new OrigDate(\n          args[0] as number,\n          (args[1] as number) ?? 0,\n          (args[2] as number) ?? 1,\n          (args[3] as number) ?? 0,\n          (args[4] as number) ?? 0,\n          (args[5] as number) ?? 0,\n          (args[6] as number) ?? 0,\n        );\n        super(tmp.getTime());\n      }\n    }\n\n    static override now(): number {\n      return clock.now();\n    }\n\n    static [Symbol.hasInstance](instance: unknown): boolean {\n      return instance instanceof OrigDate;\n    }\n  }\n\n  return VirtualDate as unknown as DateConstructor;\n}\n","import { VirtualClock } from './VirtualClock.js';\nimport { createVirtualDate } from './VirtualDate.js';\n\nexport interface ClockInstallResult {\n  clock: VirtualClock;\n  uninstall: () => void;\n}\n\nexport interface ClockInstallOptions {\n  /**\n   * If true (the default), patch `process.nextTick` to route through the virtual clock.\n   * This ensures deterministic ordering of nextTick callbacks relative to timers.\n   *\n   * Set to false only when your scenario uses dynamic `import()`, undici, or other\n   * Node.js internals that rely on `process.nextTick` for initialization, and those\n   * operations run outside of any `advance()` call (which would otherwise drain the\n   * virtual nextTick queue via `_flushMicrotasks`).\n   *\n   * @default true\n   */\n  patchNextTick?: boolean;\n}\n\n/**\n * Patch all global time primitives to use a VirtualClock.\n *\n * Returns the clock instance and an `uninstall` function that restores\n * every original global.\n */\nexport function install(clockOrStart?: VirtualClock | number, opts?: ClockInstallOptions): ClockInstallResult {\n  const clock =\n    clockOrStart instanceof VirtualClock\n      ? clockOrStart\n      : new VirtualClock(clockOrStart);\n\n  const originals = {\n    Date: globalThis.Date,\n    setTimeout: globalThis.setTimeout,\n    clearTimeout: globalThis.clearTimeout,\n    setInterval: globalThis.setInterval,\n    clearInterval: globalThis.clearInterval,\n    setImmediate: globalThis.setImmediate,\n    clearImmediate: globalThis.clearImmediate,\n    nextTick: globalThis.process?.nextTick,\n    performanceNow: globalThis.performance.now.bind(globalThis.performance),\n  };\n\n  globalThis.Date = createVirtualDate(clock);\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  (globalThis as any).setTimeout = (\n    cb: (...a: unknown[]) => void,\n    delay?: number,\n    ...args: unknown[]\n  ) => clock.setTimeout(cb, delay ?? 0, ...args);\n\n  (globalThis as any).clearTimeout = (id: number) => clock.clearTimeout(id);\n\n  (globalThis as any).setInterval = (\n    cb: (...a: unknown[]) => void,\n    delay: number,\n    ...args: unknown[]\n  ) => clock.setInterval(cb, delay, ...args);\n\n  (globalThis as any).clearInterval = (id: number) => clock.clearInterval(id);\n\n  if (typeof globalThis.setImmediate !== 'undefined') {\n    (globalThis as any).setImmediate = (cb: (...a: unknown[]) => void, ...args: unknown[]) => clock.setImmediate(cb, ...args);\n    (globalThis as any).clearImmediate = (id: number) => clock.clearImmediate(id);\n  }\n\n  if (opts?.patchNextTick !== false && globalThis.process && typeof globalThis.process.nextTick === 'function') {\n    globalThis.process.nextTick = (cb: (...a: unknown[]) => void, ...args: unknown[]) => clock.nextTick(cb, ...args);\n  }\n\n  globalThis.performance.now = () => clock.now();\n\n  function uninstall(): void {\n    globalThis.Date = originals.Date;\n    globalThis.setTimeout = originals.setTimeout;\n    globalThis.clearTimeout = originals.clearTimeout;\n    globalThis.setInterval = originals.setInterval;\n    globalThis.clearInterval = originals.clearInterval;\n    if (originals.setImmediate) globalThis.setImmediate = originals.setImmediate;\n    if (originals.clearImmediate) globalThis.clearImmediate = originals.clearImmediate;\n    if (originals.nextTick && globalThis.process) globalThis.process.nextTick = originals.nextTick;\n    globalThis.performance.now = originals.performanceNow;\n  }\n\n  return { clock, uninstall };\n}\n"],"mappings":"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","names":[]}

package/dist/install.d.ts

@@ -0,0 +1,27 @@
+import { VirtualClock } from './VirtualClock.js';
+export interface ClockInstallResult {
+    clock: VirtualClock;
+    uninstall: () => void;
+}
+export interface ClockInstallOptions {
+    /**
+     * If true (the default), patch `process.nextTick` to route through the virtual clock.
+     * This ensures deterministic ordering of nextTick callbacks relative to timers.
+     *
+     * Set to false only when your scenario uses dynamic `import()`, undici, or other
+     * Node.js internals that rely on `process.nextTick` for initialization, and those
+     * operations run outside of any `advance()` call (which would otherwise drain the
+     * virtual nextTick queue via `_flushMicrotasks`).
+     *
+     * @default true
+     */
+    patchNextTick?: boolean;
+}
+/**
+ * Patch all global time primitives to use a VirtualClock.
+ *
+ * Returns the clock instance and an `uninstall` function that restores
+ * every original global.
+ */
+export declare function install(clockOrStart?: VirtualClock | number, opts?: ClockInstallOptions): ClockInstallResult;
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CA6D5G"}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@crashlab/clock",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup && tsc --build tsconfig.json --force",
+    "clean": "rimraf dist",
+    "prepack": "npm run build",
+    "build:pkg": "tsup && tsc --build tsconfig.json --force"
+  }
+}