WebKit: use GetSystemTimePreciseAsFileTime for WallTime and QPC for MonotonicTime on Windows

scripts/build/deps/webkit.ts

@@ -7,7 +7,7 @@
 // -lto variants built with ThinLTO (per-module summaries for cross-language
 // importing), and the Windows ICU data table filtered + per-item zstd
 // compressed (lazily decompressed via bun_icu_decompress.cpp).
-export const WEBKIT_VERSION = "4895f45dfbd0d1226c4d41799887bc0ecb9f341b";
+export const WEBKIT_VERSION = "autobuild-preview-pr-304-36986ac9";
 
 /**
  * WebKit (JavaScriptCore) — the JS engine.

src/runtime/node/node_crypto_binding.rs

@@ -517,8 +517,8 @@ pub mod random {
                 }
             }
 
-            // jsDateNow() is exactly what JS Date.now() returns, so the embedded
-            // timestamp is never behind a Date.now() sample taken by the caller.
+            // Same clock source and UUID7 path as Bun.randomUUIDv7(); only the
+            // option validation and disableEntropyCache differ.
             let now_ms = global.js_date_now().max(0.0) as u64;
             let mut entropy = [0u8; 10];
             if disable_entropy_cache {

src/runtime/webcore/Blob.rs

@@ -5710,9 +5710,8 @@ pub fn jsdom_file_construct_(
     }
 
     if !set_last_modified {
-        // `lastModified` should be the current date in milliseconds if unspecified.
-        blob.last_modified
-            .set(bun_core::time::milli_timestamp() as f64);
+        // File API spec: default is "the equivalent of Date.now()".
+        blob.last_modified.set(global_this.js_date_now());
     }
 
     if blob.content_type_slice().is_empty() {

src/runtime/webcore/Crypto.rs

@@ -247,7 +247,12 @@
             .unwrap();
         }
 
-        break 'brk u64::try_from(bun_core::time::milli_timestamp().max(0)).expect("int cast");
+        // jsDateNow() is the exact value JS Date.now() would return (same
+        // precise system clock as milli_timestamp() on every platform since
+        // oven-sh/WebKit#304, plus any setSystemTime() override), so a caller
+        // bracketing this call with Date.now() always observes
+        // before <= embedded-timestamp <= after.
+        break 'brk global.js_date_now().max(0.0) as u64;
     };
 
     // SAFETY: `bun_vm()` never returns null for a Bun-owned global.

test/js/bun/util/randomUUIDv7.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe } from "harness";
+import { bunEnv, bunExe, isWindows } from "harness";
 
 describe("randomUUIDv7", () => {
   test("basic", () => {
@@ -210,4 +210,78 @@
     expect(Number(stdout.trim())).toBeGreaterThan(1);
     expect(exitCode).toBe(0);
   });
+
+  // https://github.com/oven-sh/WebKit/pull/304
+  test("default timestamp is bracketed by Date.now()", async () => {
+    // Before oven-sh/WebKit#304, Windows Date.now() (WTF QPC-interpolated) ran
+    // up to ~1ms ahead of the native precise clock the runtime read for default
+    // timestamps, so before > embedded-timestamp in ~80% of samples. With that
+    // fixed, Bun.randomUUIDv7 / crypto.randomUUIDv7 / File.lastModified all
+    // default to global.js_date_now(), which is Date.now() exactly.
+    // Subprocess keeps the process-global UUIDv7 last-timestamp untouched.
+    const N = isWindows ? 50_000 : 5_000;
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `
+          const crypto = require("node:crypto");
+          const tsOf = buf => buf.readUIntBE(0, 6);
+          const tsOfHex = s => parseInt(s.replaceAll("-", "").slice(0, 12), 16);
+          let bad = { bun: null, node: null, file: null };
+          for (let i = 0; i < ${N}; i++) {
+            const before = Date.now();
+            const b = tsOf(Bun.randomUUIDv7("buffer"));
+            const c = tsOfHex(crypto.randomUUIDv7());
+            const f = new File([], "x").lastModified;
+            const after = Date.now();
+            if (bad.bun  === null && !(before <= b && b <= after)) bad.bun  = { i, before, b, after };
+            if (bad.node === null && !(before <= c && c <= after)) bad.node = { i, before, c, after };
+            if (bad.file === null && !(before <= f && f <= after)) bad.file = { i, before, f, after };
+            if (bad.bun && bad.node && bad.file) break;
+          }
+          console.log(JSON.stringify(bad));
+        `,
+      ],
+      env: bunEnv,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual({ bun: null, node: null, file: null });
+    expect(exitCode).toBe(0);
+  });
+
+  test("default timestamp respects setSystemTime()", async () => {
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `
+          const { setSystemTime } = require("bun:test");
+          const crypto = require("node:crypto");
+          const tsOf = s => parseInt(s.replaceAll("-", "").slice(0, 12), 16);
+          const pin = 1_700_000_000_000;
+          setSystemTime(pin);
+          console.log(JSON.stringify({
+            dateNow: Date.now(),
+            bun: tsOf(Bun.randomUUIDv7()),
+            node: tsOf(crypto.randomUUIDv7()),
+            file: new File([], "x").lastModified,
+          }));
+        `,
+      ],
+      env: bunEnv,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual({
+      dateNow: 1_700_000_000_000,
+      bun: 1_700_000_000_000,
+      node: 1_700_000_000_000,
+      file: 1_700_000_000_000,
+    });
+    expect(exitCode).toBe(0);
+  });
 });